@adaptabletools/adaptable 11.0.0-canary.5 → 11.0.0-canary.6

package/src/Utilities/ExpressionFunctions/deepMap.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepMap = void 0;
+const SORT_ASC_REVISION = (p1, p2) => sortAscending(p1.revision, p2.revision);
+class DeepMap {
+    constructor(initial) {
+        this.map = new Map();
+        this.length = 0;
+        this.revision = 0;
+        this.visit = (fn) => {
+            this.map.forEach((_, k) => this.visitKey(k, this.map, [], fn));
+        };
+        this.visitDepthFirst = (fn) => {
+            this.visitWithNext([], fn);
+        };
+        this.visitWithNext = (parentKeys, fn, currentMap = this.map) => {
+            if (!currentMap) {
+                return;
+            }
+            let i = 0;
+            currentMap.forEach((_, key) => {
+                const pair = currentMap.get(key);
+                if (!pair) {
+                    return;
+                }
+                const { map } = pair;
+                const keys = [...parentKeys, key];
+                const next = map ? () => this.visitWithNext(keys, fn, map) : undefined;
+                if (pair.hasOwnProperty('value')) {
+                    fn(pair.value, keys, i, next);
+                    i++;
+                }
+                else {
+                    next === null || next === void 0 ? void 0 : next();
+                }
+            });
+        };
+        if (initial) {
+            initial.forEach((entry) => {
+                const [keys, value] = entry;
+                this.set(keys, value);
+            });
+        }
+    }
+    static clone(map) {
+        const clone = new DeepMap();
+        map.visit((pair, keys) => {
+            clone.set(keys, pair.value);
+        });
+        return clone;
+    }
+    set(keys, value) {
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot set given keys - please provide a non-empty keys array.`;
+            // currentMap.set((EMPTY_KEY as unknown) as K, { value });
+            // this.length++;
+            // return this;
+        }
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                const pair = currentMap.has(key) ? currentMap.get(key) : {};
+                pair.revision = this.revision++;
+                pair.value = value;
+                currentMap.set(key, pair);
+                this.length++;
+            }
+            else {
+                const pair = currentMap.has(key) ? currentMap.get(key) : {};
+                if (!pair.map) {
+                    pair.map = new Map();
+                    currentMap.set(key, pair);
+                }
+                currentMap = pair.map;
+            }
+        }
+        return this;
+    }
+    get(keys) {
+        var _a;
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot get given keys - please provide a non-empty keys array.`;
+            // return currentMap.get((EMPTY_KEY as unknown) as K)?.value;
+        }
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                return (_a = currentMap.get(key)) === null || _a === void 0 ? void 0 : _a.value;
+            }
+            else {
+                const pair = currentMap.get(key);
+                if (!pair || !pair.map) {
+                    return;
+                }
+                currentMap = pair.map;
+            }
+        }
+        return;
+    }
+    get size() {
+        return this.length;
+    }
+    clear() {
+        const clearMap = (map) => {
+            map.forEach((value, _key) => {
+                const { map } = value;
+                if (map) {
+                    clearMap(map);
+                }
+            });
+            map.clear();
+        };
+        clearMap(this.map);
+        this.length = 0;
+        this.revision = 0;
+    }
+    delete(keys) {
+        keys = [...keys];
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot delete given keys - please provide a non-empty keys array.`;
+            // if (currentMap.has(EMPTY_KEY as unknown as K)) {
+            //   this.length--;
+            // }
+            // return currentMap.delete((EMPTY_KEY as unknown) as K);
+        }
+        let maps = [currentMap];
+        let result = false;
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                const pair = currentMap.get(key);
+                if (pair) {
+                    if (pair.hasOwnProperty('value')) {
+                        delete pair.value;
+                        delete pair.revision;
+                        result = true;
+                        this.length--;
+                    }
+                    if (pair.map && pair.map.size === 0) {
+                        delete pair.map;
+                    }
+                    if (!pair.map) {
+                        // pair is empty, so we can remove it altogether
+                        currentMap.delete(key);
+                    }
+                }
+                break;
+            }
+            else {
+                const pair = currentMap.get(key);
+                if (!pair || !pair.map) {
+                    result = false;
+                    break;
+                }
+                currentMap = pair.map;
+                maps.push(currentMap);
+            }
+        }
+        while (maps.length) {
+            let map = maps.pop();
+            let key = keys.pop();
+            if (key && (map === null || map === void 0 ? void 0 : map.size) === 0) {
+                let parentMap = maps[maps.length - 1];
+                let pair = parentMap === null || parentMap === void 0 ? void 0 : parentMap.get(key);
+                if (pair) {
+                    // pair.map === map ; which can be deleted
+                    delete pair.map;
+                    if (!pair.hasOwnProperty('value')) {
+                        // whole pair can be successfully deleted from parentMap
+                        parentMap.delete(key);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    has(keys) {
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot find existing given keys - please provide a non-empty keys array.`;
+            // return (
+            //   currentMap.has((EMPTY_KEY as unknown) as K) &&
+            //   currentMap.get((EMPTY_KEY as unknown) as K)?.value !== undefined
+            // );
+        }
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                const pair = currentMap.get(key);
+                return !!pair && pair.hasOwnProperty('value');
+            }
+            else {
+                const pair = currentMap.get(key);
+                if (!pair || !pair.map) {
+                    return false;
+                }
+                currentMap = pair.map;
+            }
+        }
+        return false;
+    }
+    visitKey(key, currentMap, parentKeys, fn) {
+        const pair = currentMap.get(key);
+        if (!pair) {
+            return;
+        }
+        const { map } = pair;
+        const keys = [...parentKeys, key];
+        const next = once(() => {
+            if (map) {
+                map.forEach((_, k) => {
+                    this.visitKey(k, map, keys, fn);
+                });
+            }
+        });
+        if (pair.hasOwnProperty('value')) {
+            fn(pair, keys, next);
+        }
+        // if it was called by fn, it won't be called again, as it's once-d
+        next();
+    }
+    getArray(fn) {
+        const result = [];
+        this.visit((pair, keys) => {
+            result.push(fn(Object.assign(Object.assign({}, pair), { keys })));
+        });
+        return result;
+    }
+    values() {
+        return this.sortedIterator((pair) => pair.value);
+    }
+    keys() {
+        const keys = this.sortedIterator((pair) => pair.keys);
+        return keys;
+    }
+    entries() {
+        return this.sortedIterator((pair) => [pair.keys, pair.value]);
+    }
+    topDownEntries() {
+        return this.getArray((pair) => [pair.keys, pair.value]);
+    }
+    topDownKeys() {
+        return this.getArray((pair) => pair.keys);
+    }
+    topDownValues() {
+        return this.getArray((pair) => pair.value);
+    }
+    sortedIterator(fn) {
+        const result = [];
+        this.visit((pair, keys) => {
+            result.push(Object.assign(Object.assign({}, pair), { keys }));
+        });
+        result.sort(SORT_ASC_REVISION);
+        function* makeIterator() {
+            for (let i = 0, len = result.length; i < len; i++) {
+                yield fn(result[i]);
+            }
+        }
+        return makeIterator();
+    }
+}
+exports.DeepMap = DeepMap;
+function once(fn) {
+    let called = false;
+    let result = null;
+    const onceFn = () => {
+        if (called) {
+            return result;
+        }
+        called = true;
+        result = fn();
+        return result;
+    };
+    return onceFn;
+}
+const sortAscending = (a, b) => a - b;

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

@@ -0,0 +1,36 @@
+import { DeepMap } from './deepMap';
+export declare type GroupKeyType<T extends any = any> = T;
+export declare type GroupBy<DataType, KeyType> = {
+    field: keyof DataType;
+    toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
+    column?: string;
+};
+export declare type GroupParams<DataType, KeyType> = {
+    groupBy: GroupBy<DataType, KeyType>[];
+    defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
+    reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
+};
+export declare type DataSourceAggregationReducer<T, AggregationResultType> = {
+    name?: string;
+    field?: keyof T;
+    initialValue?: AggregationResultType;
+    getter?: (data: T) => any;
+    reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
+    done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
+};
+export declare type DataGroupResult<DataType, KeyType extends any> = {
+    deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
+    groupParams: GroupParams<DataType, KeyType>;
+    initialData: DataType[];
+    reducerResults?: Record<string, AggregationReducerResult>;
+};
+export declare type DeepMapGroupValueType<DataType, KeyType> = {
+    items: DataType[];
+    commonData?: Partial<DataType>;
+    reducerResults: Record<string, AggregationReducerResult>;
+};
+export declare type AggregationReducerResult<AggregationResultType extends any = any> = {
+    value: AggregationResultType;
+    id: string;
+};
+export declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;

package/src/Utilities/ExpressionFunctions/groupingMap.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.group = void 0;
+const deepMap_1 = require("./deepMap");
+function DEFAULT_TO_KEY(value) {
+    return value;
+}
+function group(groupParams, data) {
+    const { groupBy, defaultToKey = DEFAULT_TO_KEY, reducers } = groupParams;
+    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);
+            }
+        }
+        if (reducers) {
+            computeReducersFor(item, reducers, globalReducerResults);
+        }
+        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,
+        groupParams,
+        initialData: data,
+        reducerResults: globalReducerResults,
+    };
+    return result;
+}
+exports.group = group;
+function initReducers(reducers) {
+    if (!reducers || !Object.keys(reducers).length) {
+        return {};
+    }
+    const result = {};
+    for (let key in reducers)
+        if (reducers.hasOwnProperty(key)) {
+            result[key] = reducers[key].initialValue;
+        }
+    return result;
+}
+/**
+ *
+ * This fn mutates the reducerResults array!!!
+ *
+ * @param data data item
+ * @param reducers an array of reducers
+ * @param reducerResults the results on which to operate
+ *
+ */
+function computeReducersFor(data, reducers, reducerResults) {
+    var _a, _b;
+    if (!reducers || !Object.keys(reducers).length) {
+        return;
+    }
+    for (let key in reducers)
+        if (reducers.hasOwnProperty(key)) {
+            const reducer = reducers[key];
+            if (typeof reducer.reducer !== 'function') {
+                continue;
+            }
+            const currentValue = reducerResults[key];
+            const value = reducer.field ? data[reducer.field] : (_b = (_a = reducer.getter) === null || _a === void 0 ? void 0 : _a.call(reducer, data)) !== null && _b !== void 0 ? _b : null;
+            reducerResults[key] = reducer.reducer(currentValue, value, data);
+        }
+}
+function completeReducers(reducers, reducerResults, items) {
+    if (reducers) {
+        for (let key in reducers)
+            if (reducers.hasOwnProperty(key)) {
+                const reducer = reducers[key];
+                if (reducer.done) {
+                    reducerResults[key] = reducer.done(reducerResults[key], items);
+                }
+            }
+    }
+    return reducerResults;
+}

package/src/Utilities/Services/AlertService.js

@@ -55,8 +55,8 @@ class AlertService {
     isValidExpression(rule) {
         return rule.ObservableExpression
             ? this.adaptable.api.queryLanguageApi.isValidObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with observable expression `)
-            : rule.AggregationExpression
-                ? this.adaptable.api.queryLanguageApi.isValidAggregationExpression(rule.AggregationExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with aggregation expression `)
+            : rule.AggregatedBooleanExpression
+                ? this.adaptable.api.queryLanguageApi.isValidAggregatedBooleanExpression(rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with aggregation expression `)
                 : false;
     }
     evaluateReactiveExpression(rule) {
@@ -66,7 +66,7 @@ class AlertService {
                 .evaluateObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId)
             : this.adaptable.api.internalApi
                 .getQueryLanguageService()
-                .evaluateAggregationExpression(rule.AggregationExpression, ModuleConstants_1.AlertModuleId);
+                .evaluateAggregatedBooleanExpression(rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId);
     }
 }
 exports.AlertService = AlertService;

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

@@ -8,7 +8,7 @@ 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<DataChangedInfo>;
-    evaluateAggregationExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
     validateBoolean(expression: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {
@@ -19,7 +19,7 @@ export interface IQueryLanguageService extends IAdaptableService {
         isValid: boolean;
         errorMessage: string;
     };
-    validateAggregation(expression: string, module: AdaptableModule): {
+    validateAggregatedBoolean(expression: string, module: AdaptableModule): {
         isValid: boolean;
         errorMessage: string;
     };

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

@@ -15,7 +15,7 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
     evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
-    evaluateAggregationExpression(aggregationExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {
@@ -26,7 +26,7 @@ export declare class QueryLanguageService implements IQueryLanguageService {
         isValid: boolean;
         errorMessage: string;
     };
-    validateAggregation(expressionInput: string, module: AdaptableModule): {
+    validateAggregatedBoolean(expressionInput: string, module: AdaptableModule): {
         isValid: boolean;
         errorMessage: string;
     };

package/src/Utilities/Services/QueryLanguageService.js

@@ -37,13 +37,13 @@ class QueryLanguageService {
         });
         return reactiveExpression$;
     }
-    evaluateAggregationExpression(aggregationExpression, module) {
+    evaluateAggregatedBooleanExpression(aggregationExpression, module) {
         const moduleExpressionFunctions = this.getModuleExpressionFunctions(module);
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         const aggregationExpression$ = parser.evaluate(aggregationExpression, {
             node: aggregationExpression,
             api: this.adaptable.api,
-            functions: moduleExpressionFunctions.aggregationFunctions,
+            functions: moduleExpressionFunctions.aggregatedBooleanFunctions,
             whereClauseFunctions: booleanAndScalarFunctions,
         });
         return aggregationExpression$;
@@ -146,7 +146,7 @@ class QueryLanguageService {
             return result;
         }
     }
-    validateAggregation(expressionInput = '', module) {
+    validateAggregatedBoolean(expressionInput = '', module) {
         const cacheKey = this.getExpressionCacheKey(expressionInput, module);
         if (this.cacheAggregationValidation.has(cacheKey)) {
             return this.cacheAggregationValidation.get(cacheKey);
@@ -161,7 +161,7 @@ class QueryLanguageService {
             return result;
         }
         try {
-            const aggregationExpression = this.evaluateAggregationExpression(expression, module);
+            const aggregationExpression = this.evaluateAggregatedBooleanExpression(expression, module);
             if (!rxjs_1.isObservable(aggregationExpression)) {
                 const result = {
                     isValid: false,
@@ -199,7 +199,7 @@ class QueryLanguageService {
                 booleanFunctions: this.adaptable.adaptableOptions.queryLanguageOptions.defaultBooleanFunctions,
                 scalarFunctions: this.adaptable.adaptableOptions.queryLanguageOptions.defaultScalarFunctions,
                 observableFunctions: this.adaptable.adaptableOptions.queryLanguageOptions.defaultObservableFunctions,
-                aggregationFunctions: this.adaptable.adaptableOptions.queryLanguageOptions.defaultAggregationFunctions,
+                aggregatedBooleanFunctions: this.adaptable.adaptableOptions.queryLanguageOptions.defaultAggregatedBooleanFunctions,
             };
         }
         let cachedResult = this.cacheModuleSpecificExpressionFunctions.get(module);
@@ -211,7 +211,7 @@ class QueryLanguageService {
             booleanFunctions: (_c = moduleSpecificOptions.booleanFunctions) !== null && _c !== void 0 ? _c : this.adaptable.adaptableOptions.queryLanguageOptions.defaultBooleanFunctions,
             scalarFunctions: (_d = moduleSpecificOptions.scalarFunctions) !== null && _d !== void 0 ? _d : this.adaptable.adaptableOptions.queryLanguageOptions.defaultScalarFunctions,
             observableFunctions: (_e = moduleSpecificOptions.observableFunctions) !== null && _e !== void 0 ? _e : this.adaptable.adaptableOptions.queryLanguageOptions.defaultObservableFunctions,
-            aggregationFunctions: (_f = moduleSpecificOptions.aggregationFunctions) !== null && _f !== void 0 ? _f : this.adaptable.adaptableOptions.queryLanguageOptions.defaultAggregationFunctions,
+            aggregatedBooleanFunctions: (_f = moduleSpecificOptions.aggregatedBooleanFunctions) !== null && _f !== void 0 ? _f : this.adaptable.adaptableOptions.queryLanguageOptions.defaultAggregatedBooleanFunctions,
         };
         this.cacheModuleSpecificExpressionFunctions.set(module, moduleSpecificFunctions);
         return moduleSpecificFunctions;

package/src/View/AdaptableWizardView/helper.js

@@ -51,7 +51,7 @@ const typeToColType = {
     boolean: 'abColDefBoolean',
     date: 'abColDefDate',
 };
-const abColDefNumberArray = 'abColDefNumberArray';
+const abColDefCustom = 'abColDefCustom';
 exports.getColTypeFromValue = (value) => {
     const dataType = typeof value;
     let columnType = typeToColType[dataType] || typeToColType.string;
@@ -59,7 +59,7 @@ exports.getColTypeFromValue = (value) => {
         columnType = typeToColType.date;
     }
     if (Array.isArray(value) && value.length && typeof value[0] === 'number') {
-        columnType = abColDefNumberArray;
+        columnType = abColDefCustom;
     }
     return columnType;
 };

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

@@ -26,7 +26,7 @@ exports.AlertWizard = (props) => {
             : ObjectFactory_1.default.CreateEmptyAlertDefinition();
         if (!alertDefinition.Rule.BooleanExpression &&
             !alertDefinition.Rule.ObservableExpression &&
-            !alertDefinition.Rule.AggregationExpression &&
+            !alertDefinition.Rule.AggregatedBooleanExpression &&
             !alertDefinition.Rule.Predicate) {
             alertDefinition.Rule.BooleanExpression = '';
         }
@@ -72,7 +72,7 @@ exports.AlertWizard = (props) => {
                 title: 'Type & Display',
             },
             {
-                details: 'Configure behaviour for the Alert',
+                details: 'Configure Behaviour for the Alert',
                 title: 'Behaviour',
                 render: () => (React.createElement(rebass_1.Box, { padding: 2 },
                     React.createElement(AlertBehaviourWizardSection_1.AlertBehaviourWizardSection, { onChange: setAlertDefinition }))),

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

@@ -20,8 +20,8 @@ exports.BaseAlertRulesWizardSection = (props) => {
                 React.createElement("i", null, "Scope"),
                 " is 'Whole Row' - so any data change may be evaluated in a complex ObservableExpression")),
             useAggregationQuery: (React.createElement(React.Fragment, null,
-                "Use an AggregationQuery if ",
+                "Use an AggregatedBooleanQuery if ",
                 React.createElement("i", null, "Scope"),
-                " is 'Whole Row' - so any data change may be evaluated in a complex AggregationExpression")),
+                " is 'Whole Row' - so any data change may be evaluated in a complex AggregatedBooleanExpression")),
         } }));
 };

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

@@ -29,11 +29,12 @@ exports.BaseAlertScopeWizardSection = (props) => {
                     delete newData.Rule.ObservableExpression;
                     newData.Rule.BooleanExpression = '';
                 }
-                if (newData.Rule.AggregationExpression !== undefined && !api.scopeApi.scopeIsAll(Scope)) {
+                if (newData.Rule.AggregatedBooleanExpression !== undefined &&
+                    !api.scopeApi.scopeIsAll(Scope)) {
                     // if it had aggregation expression and the scope is changed to partial
                     // we need to reset to not be an aggregation expression, as aggregation is not supported
                     // for partial scope
-                    delete newData.Rule.AggregationExpression;
+                    delete newData.Rule.AggregatedBooleanExpression;
                     newData.Rule.BooleanExpression = '';
                 }
                 props.onChange(newData);

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

@@ -7,7 +7,7 @@ exports.isValidAlertRules = (alert, api, context) => {
     if (!alert.Rule.Predicate &&
         !alert.Rule.BooleanExpression &&
         !alert.Rule.ObservableExpression &&
-        !alert.Rule.AggregationExpression) {
+        !alert.Rule.AggregatedBooleanExpression) {
         return 'No condition defined for alert';
     }
     if (valid && alert.Rule.Predicate) {
@@ -35,8 +35,8 @@ exports.isValidAlertRules = (alert, api, context) => {
             return 'The query is not a valid observable query';
         }
     }
-    if (valid && alert.Rule.AggregationExpression) {
-        valid = api.queryLanguageApi.isValidAggregationExpression(alert.Rule.AggregationExpression, ModuleConstants_1.AlertModuleId);
+    if (valid && alert.Rule.AggregatedBooleanExpression) {
+        valid = api.queryLanguageApi.isValidAggregatedBooleanExpression(alert.Rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId);
         if (!valid) {
             return 'The query is not a valid aggregation query';
         }

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

@@ -44,7 +44,7 @@ exports.CalculatedColumnWizard = (props) => {
     return (React.createElement(OnePageAdaptableWizard_1.OnePageAdaptableWizard, { defaultCurrentSectionName: props.defaultCurrentSectionName, moduleInfo: props.moduleInfo, data: calculatedColumn, onHide: props.onCloseWizard, onFinish: handleFinish, sections: [
             {
                 title: 'Expression',
-                details: 'Specify the calculated column expression',
+                details: 'Specify the Calculated Column Expression',
                 isValid: CalculatedColumnExpressionWizardSection_1.isValidCalculatedColumnExpression,
                 renderSummary: CalculatedColumnExpressionWizardSection_1.renderCalculatedColumnExpressionSummary,
                 render: () => {
@@ -53,7 +53,7 @@ exports.CalculatedColumnWizard = (props) => {
             },
             {
                 title: 'Settings',
-                details: 'Specify column details and properties',
+                details: 'Specify Column details and properties',
                 isValid: CalculatedColumnSettingsWizardSection_1.isValidCalculatedColumnSettings,
                 renderSummary: CalculatedColumnSettingsWizardSection_1.renderCalculatedColumnSettingsSummary,
                 render: () => {