@adaptabletools/adaptable 12.1.7 → 12.1.8-canary.0

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.d.ts

@@ -15,7 +15,13 @@ export declare const isTextSearchCaseInsensitive: (context: ExpressionContext) =
 export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<CellDataChangedInfo>;
 export declare const handleWhereFunction: (args: any[], context: ExpressionContext) => any;
 export declare const extractColumnParameter: (consumingFunctionName: string, args: BaseParameter[]) => ColumnParameter;
-export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T["type"], allowedOperands: T["name"][], args: BaseParameter[], isOptional?: boolean) => T;
+export declare const extractColumnParameters: (consumingFunctionName: string, args: BaseParameter[]) => ColumnParameter[];
+export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T["type"], allowedOperands: T["name"][], args: BaseParameter[], config?: {
+    isOptional?: boolean;
+}) => T;
+export declare const extractParameters: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T["type"], allowedOperands: T["name"][], args: BaseParameter[], config?: {
+    isOptional?: boolean;
+}) => T[];
 export declare const handleColumnFunction: (args: any[], context: ExpressionContext) => ColumnParameter;
 export declare const getNumericValue: (input: unknown) => number;
 export declare const validateColumnType: (columnId: string, validColumnTypes: ('Number' | 'String' | 'Date')[], consumingFunction: string, api: AdaptableApi) => void;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateColumnType = exports.getNumericValue = exports.handleColumnFunction = exports.extractParameter = exports.extractColumnParameter = exports.handleWhereFunction = exports.getDataChangeLog$ = exports.isTextSearchCaseInsensitive = exports.getStringValue = exports.getStringValues = void 0;
+exports.validateColumnType = exports.getNumericValue = exports.handleColumnFunction = exports.extractParameters = exports.extractParameter = exports.extractColumnParameters = exports.extractColumnParameter = exports.handleWhereFunction = exports.getDataChangeLog$ = exports.isTextSearchCaseInsensitive = exports.getStringValue = exports.getStringValues = void 0;
 const tslib_1 = require("tslib");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
@@ -58,20 +58,33 @@ const extractColumnParameter = (consumingFunctionName, args) => {
     return exports.extractParameter(consumingFunctionName, 'config', ['COL'], args);
 };
 exports.extractColumnParameter = extractColumnParameter;
-const extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, isOptional) => {
+const extractColumnParameters = (consumingFunctionName, args) => {
+    return exports.extractParameters(consumingFunctionName, 'config', ['COL'], args);
+};
+exports.extractColumnParameters = extractColumnParameters;
+const extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
+    const parameters = exports.extractParameters(consumingFunctionName, allowedType, allowedOperands, args, config);
+    if (parameters == undefined) {
+        return;
+    }
+    if (parameters.length > 1) {
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects only 1 argument of type '${[...new Set(parameters.map((op) => op.name))].join(`' / '`)}'`);
+    }
+    return parameters[0];
+};
+exports.extractParameter = extractParameter;
+const extractParameters = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
+    const { isOptional } = config !== null && config !== void 0 ? config : {};
     const result = args.filter((arg) => (arg === null || arg === void 0 ? void 0 : arg.type) === allowedType && allowedOperands.includes(arg === null || arg === void 0 ? void 0 : arg.name));
     if (isOptional && !result.length) {
         return;
     }
-    if (result.length > 1) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects only 1 argument of type '${[...new Set(result.map((op) => op.name))].join(`' / '`)}'`);
-    }
     if (!result.length) {
         throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects an argument of type '${allowedOperands.join(`' / '`)}'`);
     }
-    return result[0];
+    return result;
 };
-exports.extractParameter = extractParameter;
+exports.extractParameters = extractParameters;
 const handleColumnFunction = (args, context) => {
     if (StringExtensions_1.default.IsNullOrEmpty(args[0])) {
         throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `no column name is provided`);
@@ -86,6 +99,9 @@ const handleColumnFunction = (args, context) => {
 };
 exports.handleColumnFunction = handleColumnFunction;
 const getNumericValue = (input) => {
+    if (typeof input === 'number') {
+        return input;
+    }
     const numericValue = toNumber_1.default(input);
     return isNaN(numericValue) ? 0 : numericValue;
 };

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.d.ts

@@ -30,4 +30,3 @@ export declare type DeepMapAggregationValueType<DataType, KeyType> = {
 };
 export declare type AggregationReducerResult = number;
 export declare function aggregate<DataType, KeyType = any>(aggregateParams: AggregateParams<DataType, KeyType>, data: DataType[]): DataAggregationResult<DataType, KeyType>;
-export declare function cumulate<DataType, KeyType = any>(aggregateParams: AggregateParams<DataType, KeyType>, data: DataType[]): DataAggregationResult<DataType, KeyType>;

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cumulate = exports.aggregate = void 0;
+exports.aggregate = void 0;
 const deepMap_1 = require("./deepMap");
 function DEFAULT_TO_KEY(value) {
     return value;
@@ -10,57 +10,10 @@ function aggregate(aggregateParams, data) {
     const groupByLength = groupBy.length;
     const deepMap = new deepMap_1.DeepMap();
     let currentGroupKeys = [];
-    const initialReducerValue = initReducers(reducers);
-    const globalReducerResults = Object.assign({}, initialReducerValue);
-    for (let i = 0, len = data.length; i < len; i++) {
-        let item = data[i];
-        for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
-            const { field: groupByProperty, toKey: groupToKey } = groupBy[groupByIndex];
-            const key = (groupToKey || defaultToKey)(item[groupByProperty], item);
-            currentGroupKeys.push(key);
-            if (!deepMap.has(currentGroupKeys)) {
-                const deepMapGroupValue = {
-                    items: [],
-                    reducerResults: Object.assign({}, initialReducerValue),
-                };
-                deepMap.set(currentGroupKeys, deepMapGroupValue);
-            }
-            const { items: currentGroupItems, reducerResults } = deepMap.get(currentGroupKeys);
-            currentGroupItems.push(item);
-            if (reducers) {
-                computeReducersFor(item, reducers, reducerResults, i);
-            }
-        }
-        if (reducers) {
-            computeReducersFor(item, reducers, globalReducerResults, i);
-        }
-        currentGroupKeys.length = 0;
-    }
-    if (reducers) {
-        deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
-            completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
-            next === null || next === void 0 ? void 0 : next();
-        });
-    }
-    if (reducers) {
-        completeReducers(reducers, globalReducerResults, data);
-    }
-    const result = {
-        deepMap,
-        aggregateParams,
-        initialData: data,
-        reducerResults: globalReducerResults,
+    const getInitialReducerValue = () => {
+        return JSON.parse(JSON.stringify(initReducers(reducers)));
     };
-    return result;
-}
-exports.aggregate = aggregate;
-function cumulate(aggregateParams, data) {
-    const { groupBy = [], defaultToKey = DEFAULT_TO_KEY, reducers } = aggregateParams;
-    const groupByLength = groupBy.length;
-    const deepMap = new deepMap_1.DeepMap();
-    let currentGroupKeys = [];
-    let initialReducerValue = initReducers(reducers);
-    const globalReducerResults = Object.assign({}, initialReducerValue);
+    const globalReducerResults = getInitialReducerValue();
     for (let i = 0, len = data.length; i < len; i++) {
         let item = data[i];
         for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
@@ -70,7 +23,7 @@ function cumulate(aggregateParams, data) {
             if (!deepMap.has(currentGroupKeys)) {
                 const deepMapGroupValue = {
                     items: [],
-                    reducerResults: Object.assign({}, initialReducerValue),
+                    reducerResults: getInitialReducerValue(),
                 };
                 deepMap.set(currentGroupKeys, deepMapGroupValue);
             }
@@ -83,7 +36,6 @@ function cumulate(aggregateParams, data) {
         if (reducers) {
             computeReducersFor(item, reducers, globalReducerResults, i);
         }
-        initialReducerValue = Object.assign({}, deepMap.get(currentGroupKeys).reducerResults);
         currentGroupKeys.length = 0;
     }
     if (reducers) {
@@ -103,7 +55,7 @@ function cumulate(aggregateParams, data) {
     };
     return result;
 }
-exports.cumulate = cumulate;
+exports.aggregate = aggregate;
 function initReducers(reducers) {
     if (!reducers || !Object.keys(reducers).length) {
         return {};

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -30,7 +30,12 @@ const sanitizeNumericResult = (value) => {
 exports.scalarExpressionFunctions = {
     ADD: {
         handler(args) {
-            return sanitizeArguments(args, true).reduce((a, b) => a + b);
+            const sanitizedArguments = sanitizeArguments(args, true);
+            if (args.length && !sanitizedArguments.length) {
+                // expression is syntactically valid, but operates with incompatible values
+                return;
+            }
+            return sanitizedArguments.reduce((a, b) => a + b);
         },
         isHiddenFromMenu: true,
         description: 'Returns the sum of 2 numbers',
@@ -39,7 +44,12 @@ exports.scalarExpressionFunctions = {
     },
     SUB: {
         handler(args) {
-            return sanitizeArguments(args).reduce((a, b) => a - b);
+            const sanitizedArguments = sanitizeArguments(args);
+            if (args.length && !sanitizedArguments.length) {
+                // expression is syntactically valid, but operates with incompatible values
+                return;
+            }
+            return sanitizedArguments.reduce((a, b) => a - b);
         },
         isHiddenFromMenu: true,
         description: 'Returns the difference of 2 numbers',
@@ -126,10 +136,12 @@ exports.scalarExpressionFunctions = {
     },
     AVG: {
         handler(args) {
-            if (args.length === 0) {
-                return 0;
+            const sanitizedArguments = sanitizeArguments(args);
+            if (args.length && !sanitizedArguments.length) {
+                // expression is syntactically valid, but operates with incompatible values
+                return;
             }
-            return sanitizeArguments(args).reduce((a, b) => a + b) / args.length;
+            return sanitizedArguments.reduce((a, b) => a + b) / args.length;
         },
         description: 'Returns the average of inputted numbers',
         signatures: ['AVG(number, number, ...number)'],

package/src/Utilities/Interface/MessagePopups.d.ts

@@ -2,7 +2,6 @@ import { Action } from 'redux';
 import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { AdaptableMessageType } from '../../PredefinedConfig/Common/AdaptableMessageType';
-import { AdaptableAlert } from '../../PredefinedConfig/Common/AdaptableAlert';
 import { AdaptableForm, BaseContext } from '../../types';
 export interface UIConfirmation {
     Header: string;
@@ -36,9 +35,6 @@ export interface ScreenPopup {
 export interface LoadingPopup {
     ShowLoadingPopup: boolean;
 }
-export interface AlertPopup {
-    Alert: AdaptableAlert | null;
-}
 export interface ConfirmationPopup {
     ShowConfirmationPopup: boolean;
     Header: string;

package/src/Utilities/ObjectFactory.d.ts

@@ -6,7 +6,7 @@ import { AlertDefinition, AlertProperties } from '../PredefinedConfig/AlertState
 import { Layout } from '../PredefinedConfig/LayoutState';
 import { Report, ReportSchedule } from '../PredefinedConfig/ExportState';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
-import { Schedule, BaseSchedule } from '../PredefinedConfig/Common/Schedule';
+import { BaseSchedule, Schedule } from '../PredefinedConfig/Common/Schedule';
 import { Shortcut } from '../PredefinedConfig/ShortcutState';
 import { ConditionalStyle } from '../PredefinedConfig/ConditionalStyleState';
 import { FormatColumn } from '../PredefinedConfig/FormatColumnState';
@@ -16,7 +16,7 @@ import { CellDataChangedInfo } from '../PredefinedConfig/Common/CellDataChangedI
 import { Glue42Report, Glue42Schedule } from '../PredefinedConfig/Glue42State';
 import { IPushPullReport } from '../PredefinedConfig/SystemState';
 import { IPushPullSchedule } from '../PredefinedConfig/IPushPullState';
-import { OpenFinSchedule, OpenFinReport } from '../PredefinedConfig/OpenFinState';
+import { OpenFinReport, OpenFinSchedule } from '../PredefinedConfig/OpenFinState';
 import { NamedQuery } from '../PredefinedConfig/QueryState';
 import { ReminderSchedule } from '../PredefinedConfig/ScheduleState';
 import { AdaptableCellChangedAlert, AdaptableGenericAlert, AdaptableRowChangedAlert } from '../PredefinedConfig/Common/AdaptableAlert';
@@ -39,6 +39,7 @@ export declare function CreateEmptyAlertDefinition(): AlertDefinition;
 export declare function CreateEmptyFlashingCellDefinition(): FlashingCellDefinition;
 export declare function CreateInternalAlertDefinitionForMessages(messageType: AdaptableMessageType, alertProperties?: AlertProperties): AlertDefinition;
 export declare function CreateEmptyReport(): Report;
+export declare function CreateCustomReport(reportName: string): Report;
 export declare function CreateEmptyBaseSchedule(scheduleType: ScheduleType): BaseSchedule;
 export declare function CreateEmptyReminderSchedule(): ReminderSchedule;
 export declare function CreateEmptyReportSchedule(): ReportSchedule;
@@ -79,6 +80,7 @@ export declare const ObjectFactory: {
     CreateEmptyAlertDefinition: typeof CreateEmptyAlertDefinition;
     CreateEmptyFlashingCellDefinition: typeof CreateEmptyFlashingCellDefinition;
     CreateInternalAlertDefinitionForMessages: typeof CreateInternalAlertDefinitionForMessages;
+    CreateCustomReport: typeof CreateCustomReport;
     CreateEmptyReport: typeof CreateEmptyReport;
     CreateEmptyBaseSchedule: typeof CreateEmptyBaseSchedule;
     CreateEmptyReminderSchedule: typeof CreateEmptyReminderSchedule;

package/src/Utilities/ObjectFactory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectFactory = exports.CreateToastOptions = exports.CreateCustomDisplayFormatterContext = exports.CreateColumnFilter = exports.CreateEmptyCellSummmary = exports.CreateSystemStatusMessageInfo = exports.CreateEmptyStyle = exports.CreateEmptyLayout = exports.CreateEmptyFreeTextColumn = exports.CreateEmptyFormatColumn = exports.CreateEmptyConditionalStyle = exports.CreateEmptyShortcut = exports.CreateEmptySchedule = exports.CreateReportSchedule = exports.CreateGlue42Schedule = exports.CreateIPushPullSchedule = exports.CreateEmptyOpenFinSchedule = exports.CreateEmptyGlue42Schedule = exports.CreateEmptyIPushPullSchedule = exports.CreateEmptyOpenFinReport = exports.CreateEmptyGlue42Report = exports.CreateEmptyIPushPullReport = exports.CreateEmptyReportSchedule = exports.CreateEmptyReminderSchedule = exports.CreateEmptyBaseSchedule = exports.CreateEmptyReport = exports.CreateInternalAlertDefinitionForMessages = exports.CreateEmptyFlashingCellDefinition = exports.CreateEmptyAlertDefinition = exports.CreateRowChangedAlert = exports.CreateCellChangedAlert = exports.CreateGenericAlert = exports.CreateEmptyPlusMinusNudge = exports.CreateEmptyNamedQuery = exports.CreateEmptyCalculatedColumn = exports.CreateEmptyCustomSort = void 0;
+exports.ObjectFactory = exports.CreateToastOptions = exports.CreateCustomDisplayFormatterContext = exports.CreateColumnFilter = exports.CreateEmptyCellSummmary = exports.CreateSystemStatusMessageInfo = exports.CreateEmptyStyle = exports.CreateEmptyLayout = exports.CreateEmptyFreeTextColumn = exports.CreateEmptyFormatColumn = exports.CreateEmptyConditionalStyle = exports.CreateEmptyShortcut = exports.CreateEmptySchedule = exports.CreateReportSchedule = exports.CreateGlue42Schedule = exports.CreateIPushPullSchedule = exports.CreateEmptyOpenFinSchedule = exports.CreateEmptyGlue42Schedule = exports.CreateEmptyIPushPullSchedule = exports.CreateEmptyOpenFinReport = exports.CreateEmptyGlue42Report = exports.CreateEmptyIPushPullReport = exports.CreateEmptyReportSchedule = exports.CreateEmptyReminderSchedule = exports.CreateEmptyBaseSchedule = exports.CreateCustomReport = exports.CreateEmptyReport = exports.CreateInternalAlertDefinitionForMessages = exports.CreateEmptyFlashingCellDefinition = exports.CreateEmptyAlertDefinition = exports.CreateRowChangedAlert = exports.CreateCellChangedAlert = exports.CreateGenericAlert = exports.CreateEmptyPlusMinusNudge = exports.CreateEmptyNamedQuery = exports.CreateEmptyCalculatedColumn = exports.CreateEmptyCustomSort = void 0;
 const Enums_1 = require("../PredefinedConfig/Common/Enums");
 const GeneralConstants_1 = require("./Constants/GeneralConstants");
 const Uuid_1 = require("../PredefinedConfig/Uuid");
@@ -18,6 +18,7 @@ function CreateEmptyCalculatedColumn() {
         },
         // need to create some defaults - which we will change later
         CalculatedColumnSettings: {
+            DataType: undefined,
             Filterable: false,
             Resizable: false,
             Groupable: false,
@@ -123,12 +124,23 @@ function CreateEmptyReport() {
         Uuid: Uuid_1.createUuid(),
         Name: GeneralConstants_1.EMPTY_STRING,
         Scope: undefined,
-        ReportColumnScope: Enums_1.ReportColumnScope.AllColumns,
-        ReportRowScope: Enums_1.ReportRowScope.AllRows,
+        ReportColumnScope: 'AllColumns',
+        ReportRowScope: 'AllRows',
         Query: undefined,
     };
 }
 exports.CreateEmptyReport = CreateEmptyReport;
+function CreateCustomReport(reportName) {
+    return {
+        Uuid: Uuid_1.createUuid(),
+        Name: reportName,
+        Scope: undefined,
+        ReportColumnScope: 'AllColumns',
+        ReportRowScope: 'AllRows',
+        Query: undefined,
+    };
+}
+exports.CreateCustomReport = CreateCustomReport;
 function CreateEmptyBaseSchedule(scheduleType) {
     return {
         Uuid: Uuid_1.createUuid(),
@@ -429,6 +441,7 @@ exports.ObjectFactory = {
     CreateEmptyAlertDefinition,
     CreateEmptyFlashingCellDefinition,
     CreateInternalAlertDefinitionForMessages,
+    CreateCustomReport,
     CreateEmptyReport,
     CreateEmptyBaseSchedule,
     CreateEmptyReminderSchedule,

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

@@ -0,0 +1,25 @@
+import { AggregatedScalarExpressionEvaluation } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
+import { AdaptableApi } from '../../Api/AdaptableApi';
+import { AdaptableModule as ModuleConstants } from '../../PredefinedConfig/Common/Types';
+import { RowNode } from '@ag-grid-community/all-modules';
+import { XOR } from '../Extensions/TypeExtensions';
+export declare class AggregatedScalarLiveValue {
+    private source;
+    private requestingModule;
+    private adaptableApi;
+    private aggregationReducerName;
+    private aggregatedScalarExpression;
+    private expressionEvaluation;
+    private aggregationResult;
+    constructor(source: XOR<{
+        aggregatedScalarExpression: string;
+    }, {
+        aggregatedScalarExpressionEvaluation: AggregatedScalarExpressionEvaluation;
+    }>, requestingModule: ModuleConstants, adaptableApi: AdaptableApi);
+    refresh(): void;
+    getAggregatedValueForRow(rowNode: RowNode): any;
+    getAllAggregationValues(): number[];
+    private getAggregationValue;
+    private getGlobalAggregatedValue;
+    private computeAggregatedValue;
+}

package/src/Utilities/Services/AggregatedScalarLiveValue.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregatedScalarLiveValue = void 0;
+const scalarAggregationHelper_1 = require("../ExpressionFunctions/scalarAggregationHelper");
+class AggregatedScalarLiveValue {
+    constructor(source, requestingModule, adaptableApi) {
+        this.source = source;
+        this.requestingModule = requestingModule;
+        this.adaptableApi = adaptableApi;
+        if (source.aggregatedScalarExpression) {
+            this.aggregatedScalarExpression = source.aggregatedScalarExpression;
+        }
+        this.expressionEvaluation = source.aggregatedScalarExpression
+            ? this.adaptableApi.internalApi
+                .getQueryLanguageService()
+                .evaluateAggregatedScalarExpression(source.aggregatedScalarExpression, requestingModule)
+                .value
+            : source.aggregatedScalarExpressionEvaluation;
+        // currently we support only one reducer
+        this.aggregationReducerName = Object.keys(this.expressionEvaluation.aggregationParams.reducers)[0];
+        this.aggregationResult = this.computeAggregatedValue(this.expressionEvaluation);
+    }
+    refresh() {
+        if (this.aggregatedScalarExpression) {
+            this.expressionEvaluation = this.adaptableApi.internalApi
+                .getQueryLanguageService()
+                .evaluateAggregatedScalarExpression(this.aggregatedScalarExpression, this.requestingModule).value;
+        }
+        // currently we support only one reducer
+        this.aggregationReducerName = Object.keys(this.expressionEvaluation.aggregationParams.reducers)[0];
+        this.aggregationResult = this.computeAggregatedValue(this.expressionEvaluation);
+    }
+    getAggregatedValueForRow(rowNode) {
+        const aggregationValue = this.getAggregationValue(rowNode);
+        if (this.expressionEvaluation.rowValueGetter) {
+            return this.expressionEvaluation.rowValueGetter(rowNode, aggregationValue);
+        }
+        return aggregationValue;
+    }
+    getAllAggregationValues() {
+        var _a;
+        if ((_a = this.expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
+            const aggregations = this.aggregationResult.deepMap.topDownValues();
+            return aggregations.map((aggregation) => aggregation.reducerResults[this.aggregationReducerName]);
+        }
+        return [this.getGlobalAggregatedValue()];
+    }
+    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.getGlobalAggregatedValue();
+    }
+    getGlobalAggregatedValue() {
+        return this.aggregationResult.reducerResults[this.aggregationReducerName];
+    }
+    computeAggregatedValue(expressionEvaluation) {
+        var _a;
+        const gridRowNodes = this.adaptableApi.gridApi.getAllRowNodes({
+            filterFn: expressionEvaluation.rowFilterFn,
+        });
+        // 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);
+        });
+        let aggregatedRowNodes = gridRowNodes;
+        if (expressionEvaluation.sortByColumn) {
+            const sortByColumn = expressionEvaluation.sortByColumn;
+            const getRowNodeValue = (rowNode, columnId) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, columnId);
+            // 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);
+    }
+}
+exports.AggregatedScalarLiveValue = AggregatedScalarLiveValue;

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

@@ -11,6 +11,5 @@ export declare class AlertService implements IAlertService {
     onReactiveAlertTriggered: (callback: EmitterCallback) => (() => void);
     createReactiveAlert(alertDefinition: AlertDefinition): void;
     deleteReactiveAlert(alertDefinition: AlertDefinition): void;
-    private isValidExpression;
     private evaluateReactiveExpression;
 }

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;
 }