@adaptabletools/adaptable 11.0.0-canary.6 → 11.0.1

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -2,19 +2,316 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aggregatedScalarExpressionFunctions = void 0;
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 exports.aggregatedScalarExpressionFunctions = {
-    CUMSUM: {
+    SUM: {
         handler(args, context) {
-            const cumulatedColumnParameter = expressionFunctionUtils_1.extractColumnParameter('SUM', args);
-            expressionFunctionUtils_1.validateColumnType(cumulatedColumnParameter.value, ['Number'], 'CUMSUM', context.api);
-            const overColumnParameter = expressionFunctionUtils_1.extractParameter('CUMSUM', 'operand', ['OVER'], args);
-            // sort over all rowNodes by overColumn
-            // cumulate
-            //save to map
+            const sumColumnParameter = expressionFunctionUtils_1.extractColumnParameter('SUM', args);
+            const sumColumnName = sumColumnParameter.value;
+            expressionFunctionUtils_1.validateColumnType(sumColumnName, ['Number'], 'SUM', context.api);
+            const groupByParameter = expressionFunctionUtils_1.extractParameter('SUM', 'operand', ['GROUP_BY'], args, true);
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        SUM: {
+                            name: 'SUM',
+                            field: sumColumnName,
+                            initialValue: 0,
+                            reducer: (totalSum, rowValue) => {
+                                if (!rowValue) {
+                                    return totalSum;
+                                }
+                                return totalSum + rowValue;
+                            },
+                        },
+                    },
+                },
+                columnDependencies: [sumColumnName],
+            };
+            if (groupByParameter) {
+                const groupByColumnName = groupByParameter.value;
+                aggregationExpressionEvaluation.aggregationParams.groupBy = [
+                    {
+                        field: groupByColumnName,
+                    },
+                ];
+                aggregationExpressionEvaluation.columnDependencies.push(groupByColumnName);
+            }
+            const result = {
+                name: 'SUM',
+                type: 'aggregation',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by summing up the column values\nOptionally the aggregation may be computed within provided individual groups',
+        signatures: [
+            'SUM( [colName] )',
+            'SUM( COL(name: string))',
+            'SUM( [colNameA], GROUP_BY( [colNameB] ))',
+            'SUM( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['SUM([colA])', 'SUM([colA], GROUP_BY([colB]))'],
+    },
+    PERCENTAGE: {
+        handler(args, context) {
+            var _a;
+            const percentageColumnParameter = expressionFunctionUtils_1.extractColumnParameter('PERCENTAGE', args);
+            const percentageColumnName = percentageColumnParameter.value;
+            expressionFunctionUtils_1.validateColumnType(percentageColumnName, ['Number'], 'PERCENTAGE', context.api);
+            const sumOperand = expressionFunctionUtils_1.extractParameter('PERCENTAGE', 'aggregation', ['SUM'], args, true);
+            const groupByOperand = expressionFunctionUtils_1.extractParameter('PERCENTAGE', 'operand', ['GROUP_BY'], args, true);
+            if (sumOperand && groupByOperand) {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('PERCENTAGE', `expects either a SUM or a GROUP_BY argument`);
+            }
+            const sumAggregationColumnName = sumOperand
+                ? sumOperand.value.aggregationParams.reducers['SUM'].field
+                : percentageColumnName;
+            const groupByColumnName = groupByOperand
+                ? groupByOperand.value
+                : (_a = sumOperand === null || sumOperand === void 0 ? void 0 : sumOperand.value.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a[0].field;
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        PERCENTAGE: {
+                            name: 'PERCENTAGE',
+                            field: sumAggregationColumnName,
+                            initialValue: 0,
+                            reducer: (totalSum, rowValue) => {
+                                if (!rowValue) {
+                                    return totalSum;
+                                }
+                                return totalSum + rowValue;
+                            },
+                        },
+                    },
+                },
+                rowValueGetter: (rowNode, aggregationValue) => {
+                    return ((context.api.gridApi.getRawValueFromRowNode(rowNode, percentageColumnName) /
+                        aggregationValue) *
+                        100);
+                },
+                columnDependencies: [...new Set([percentageColumnName, sumAggregationColumnName])],
+            };
+            if (groupByColumnName) {
+                aggregationExpressionEvaluation.aggregationParams.groupBy = [
+                    {
+                        field: groupByColumnName,
+                    },
+                ];
+                aggregationExpressionEvaluation.columnDependencies.push(groupByColumnName);
+            }
+            const result = {
+                name: 'PERCENTAGE',
+                type: 'aggregation',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Divides each column value by the aggregated sum of a column\nThe column with the aggregated value and the column with the percentage value do not necessarily have to be identical',
+        signatures: [
+            'PERCENTAGE( [colName] )',
+            'PERCENTAGE( [colNameA], GROUP_BY( [colNameB] ))',
+            'PERCENTAGE( [colNameA], SUM ( [colNameB] ))',
+            'PERCENTAGE( [colNameA], SUM ( [colNameB], GROUP_BY( [colNameC] )))',
+        ],
+        examples: [
+            'PERCENTAGE( [colName] )',
+            'PERCENTAGE( [colNameA], GROUP_BY( [colNameB] ))',
+            'PERCENTAGE( [colNameA], SUM ( [colNameB] ))',
+            'PERCENTAGE( [colNameA], SUM ( [colNameB], GROUP_BY( [colNameC] )))',
+        ],
+    },
+    AVG: {
+        handler(args, context) {
+            const avgColumnParameter = expressionFunctionUtils_1.extractColumnParameter('AVG', args);
+            const avgColumnName = avgColumnParameter.value;
+            expressionFunctionUtils_1.validateColumnType(avgColumnName, ['Number'], 'AVG', context.api);
+            const groupByParameter = expressionFunctionUtils_1.extractParameter('AVG', 'operand', ['GROUP_BY'], args, true);
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        SUM: {
+                            name: 'AVG',
+                            field: avgColumnName,
+                            initialValue: 0,
+                            reducer: (totalSum, rowValue) => {
+                                if (!rowValue) {
+                                    return totalSum;
+                                }
+                                return totalSum + rowValue;
+                            },
+                            done: (value, dataArray) => {
+                                return dataArray.length ? value / dataArray.length : 0;
+                            },
+                        },
+                    },
+                },
+                columnDependencies: [avgColumnName],
+            };
+            if (groupByParameter) {
+                const groupByColumnName = groupByParameter.value;
+                aggregationExpressionEvaluation.aggregationParams.groupBy = [
+                    {
+                        field: groupByColumnName,
+                    },
+                ];
+                aggregationExpressionEvaluation.columnDependencies.push(groupByColumnName);
+            }
+            const result = {
+                name: 'AVG',
+                type: 'aggregation',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the average value (arithmetic mean) of the column values\nOptionally the aggregation may be computed within provided individual groups',
+        signatures: [
+            'AVG( [colName] )',
+            'AVG( COL(name: string))',
+            'AVG( [colNameA], GROUP_BY( [colNameB] ))',
+            'AVG( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['AVG([colA])', 'AVG([colA], GROUP_BY([colB]))'],
+    },
+    MIN: {
+        handler(args, context) {
+            const minColumnParameter = expressionFunctionUtils_1.extractColumnParameter('MIN', args);
+            const minColumnName = minColumnParameter.value;
+            expressionFunctionUtils_1.validateColumnType(minColumnName, ['Number'], 'MIN', context.api);
+            const groupByParameter = expressionFunctionUtils_1.extractParameter('MIN', 'operand', ['GROUP_BY'], args, true);
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        SUM: {
+                            name: 'MIN',
+                            field: minColumnName,
+                            initialValue: Number.MAX_VALUE,
+                            reducer: (minValue, rowValue) => {
+                                if (!rowValue) {
+                                    return minValue;
+                                }
+                                return rowValue < minValue ? rowValue : minValue;
+                            },
+                        },
+                    },
+                },
+                columnDependencies: [minColumnName],
+            };
+            if (groupByParameter) {
+                const groupByColumnName = groupByParameter.value;
+                aggregationExpressionEvaluation.aggregationParams.groupBy = [
+                    {
+                        field: groupByColumnName,
+                    },
+                ];
+                aggregationExpressionEvaluation.columnDependencies.push(groupByColumnName);
+            }
+            const result = {
+                name: 'MIN',
+                type: 'aggregation',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the minimum of the column values\nOptionally the aggregation may be computed within provided individual groups',
+        signatures: [
+            'MIN( [colName] )',
+            'MIN( COL(name: string))',
+            'MIN( [colNameA], GROUP_BY( [colNameB] ))',
+            'MIN( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
+    },
+    MAX: {
+        handler(args, context) {
+            const maxColumnParameter = expressionFunctionUtils_1.extractColumnParameter('MAX', args);
+            const maxColumnName = maxColumnParameter.value;
+            expressionFunctionUtils_1.validateColumnType(maxColumnName, ['Number'], 'MAX', context.api);
+            const groupByParameter = expressionFunctionUtils_1.extractParameter('MAX', 'operand', ['GROUP_BY'], args, true);
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        SUM: {
+                            name: 'MAX',
+                            field: maxColumnName,
+                            initialValue: Number.MIN_VALUE,
+                            reducer: (maxValue, rowValue) => {
+                                if (!rowValue) {
+                                    return maxValue;
+                                }
+                                return rowValue > maxValue ? rowValue : maxValue;
+                            },
+                        },
+                    },
+                },
+                columnDependencies: [maxColumnName],
+            };
+            if (groupByParameter) {
+                const groupByColumnName = groupByParameter.value;
+                aggregationExpressionEvaluation.aggregationParams.groupBy = [
+                    {
+                        field: groupByColumnName,
+                    },
+                ];
+                aggregationExpressionEvaluation.columnDependencies.push(groupByColumnName);
+            }
+            const result = {
+                name: 'MAX',
+                type: 'aggregation',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the maximum of the column values\nOptionally the aggregation may be computed within provided individual groups',
+        signatures: [
+            'MAX( [colName] )',
+            'MAX( COL(name: string))',
+            'MAX( [colNameA], GROUP_BY( [colNameB] ))',
+            'MAX( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
+    },
+    GROUP_BY: {
+        handler(args, context) {
+            const columnParameter = expressionFunctionUtils_1.extractColumnParameter('GROUP_BY', args);
+            const result = {
+                type: 'operand',
+                name: 'GROUP_BY',
+                value: columnParameter.value,
+            };
+            return result;
+        },
+        description: 'Groups an aggregation operation within the rows that have the same value in the specified column',
+        signatures: ['GROUP_BY( [colName] )', 'GROUP_BY( COL(name: string))'],
+        examples: ['GROUP_BY( [colName] )', `GROUP_BY( COL('colName'))`],
+    },
+    CUMUL: {
+        handler(args, context) {
+            var _a;
+            const aggregationParameter = expressionFunctionUtils_1.extractParameter('CUMUL', 'aggregation', ['SUM', 'MIN', 'MAX', 'PERCENTAGE', 'AVG'], args);
+            if (aggregationParameter.name === 'AVG' || aggregationParameter.name === 'PERCENTAGE') {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('CUMUL', `supports only following aggregations: SUM, MIN, MAX`);
+            }
+            if ((_a = aggregationParameter.value.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('CUMUL', `supports only aggregations without any grouping (GROUP_BY clauses)`);
+            }
+            const overColumnParameter = expressionFunctionUtils_1.extractParameter('CUMUL', 'operand', ['OVER'], args);
+            aggregationParameter.value.cumulateOver = overColumnParameter.value;
+            const result = {
+                name: 'CUMUL',
+                type: 'aggregation',
+                value: aggregationParameter.value,
+            };
+            return result;
         },
-        description: 'TODO',
-        signatures: ['TODO'],
-        examples: ['TODO'],
+        description: 'Performs a cumulative aggregation (running total) with the given aggregation operation over a provided column',
+        signatures: ['CUMUL( aggregationOp: SUM|MIN|MAX, OVER( [colNameB] ))'],
+        examples: [
+            'CUMUL( SUM([colNameA]), OVER( [colNameB] ))',
+            'CUMUL( MIN([colNameA]), OVER( [colNameB] ))',
+            'CUMUL( MAX([colNameA]), OVER( [colNameB] ))',
+        ],
     },
     OVER: {
         handler(args, context) {
@@ -27,15 +324,15 @@ exports.aggregatedScalarExpressionFunctions = {
             };
             return result;
         },
-        description: 'TODO',
-        signatures: ['TODO'],
-        examples: ['TODO'],
+        description: 'Defines an accumulative dimension (order) for the enclosing cumulative aggregation',
+        signatures: ['OVER( [colName] )', 'OVER( COL(name: string))'],
+        examples: ['OVER( [colName] )', `OVER( COL('colName'))`],
     },
     COL: {
         handler(args, context) {
             return expressionFunctionUtils_1.handleColumnFunction(args, context);
         },
-        description: 'Returns the value of a column',
+        description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
         examples: ['[col1]', 'COL("col1")'],
     },

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

@@ -14,8 +14,8 @@ export declare const getStringValue: (context: ExpressionContext, stringArgument
 export declare const isTextSearchCaseInsensitive: (context: ExpressionContext) => boolean;
 export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<DataChangedInfo>;
 export declare const handleWhereFunction: (args: any[], context: ExpressionContext) => any;
-export declare const extractColumnParameter: (consumingFunctionName: string, args: BaseParameter[], validateType?: 'number') => ColumnParameter;
-export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: string, allowedOperands: string[], args?: BaseParameter[]) => T;
+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 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

@@ -49,19 +49,19 @@ exports.handleWhereFunction = (args, context) => {
         filterFn,
     });
 };
-exports.extractColumnParameter = (consumingFunctionName, args, validateType) => {
-    const result = exports.extractParameter(consumingFunctionName, 'config', ['COL'], args);
-    if (validateType) {
-    }
-    return result;
+exports.extractColumnParameter = (consumingFunctionName, args) => {
+    return exports.extractParameter(consumingFunctionName, 'config', ['COL'], args);
 };
-exports.extractParameter = (consumingFunctionName, allowedType, allowedOperands, args = []) => {
+exports.extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, isOptional) => {
     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(' / ')}'`);
+        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(' / ')}'`);
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects an argument of type '${allowedOperands.join(`' / '`)}'`);
     }
     return result[0];
 };

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

@@ -3,7 +3,6 @@ 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>[];
@@ -22,12 +21,12 @@ 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>;
+    reducerResults?: Record<string, any>;
 };
 export declare type DeepMapGroupValueType<DataType, KeyType> = {
     items: DataType[];
     commonData?: Partial<DataType>;
-    reducerResults: Record<string, AggregationReducerResult>;
+    reducerResults: Record<string, any>;
 };
 export declare type AggregationReducerResult<AggregationResultType extends any = any> = {
     value: AggregationResultType;

package/src/Utilities/ExpressionFunctions/groupingMap.js

@@ -36,13 +36,14 @@ function group(groupParams, data) {
         }
         currentGroupKeys.length = 0;
     }
-    if (reducers) {
+    const hasReducersWithDoneFn = reducers && Object.values(reducers).some((reducer) => reducer.done);
+    if (hasReducersWithDoneFn) {
         deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
             completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
             next === null || next === void 0 ? void 0 : next();
         });
     }
-    if (reducers) {
+    if (hasReducersWithDoneFn) {
         completeReducers(reducers, globalReducerResults, data);
     }
     const result = {

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -105,7 +105,7 @@ exports.observableExpressionFunctions = {
         handler(args, context) {
             return expressionFunctionUtils_1.handleColumnFunction(args, context);
         },
-        description: 'References a grid column by name',
+        description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
         examples: ['[col1]', "COL('col1')"],
     },
@@ -417,7 +417,8 @@ const getSlidingTimeframe$ = (source$, timeframeDuration, onTimeframeEnter, onTi
     }));
 };
 const getMaxTimeframeSize = (expressionValue, context) => {
-    let maxTimeframeSize = context.api.internalApi.getAdaptableOptions().queryLanguageOptions.maxTimeframeSize;
+    let maxTimeframeSize = context.api.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
+        .maxTimeframeSize;
     if (maxTimeframeSize > SYSTEM_MAX_TIMEFRAME_SIZE) {
         maxTimeframeSize = SYSTEM_MAX_TIMEFRAME_SIZE;
     }

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

@@ -0,0 +1,33 @@
+import { DeepMap } from './deepMap';
+export declare type GroupKeyType<T extends any = any> = T;
+export declare type GroupBy<DataType, KeyType> = {
+    field: keyof DataType & string;
+    toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
+};
+export declare type AggregateParams<DataType, KeyType> = {
+    reducers: Record<string, DataAggregationReducer<DataType, any>>;
+    groupBy?: GroupBy<DataType, KeyType>[];
+    defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
+};
+export declare type DataAggregationReducer<T, AggregationResultType> = {
+    name?: string;
+    field?: keyof T & string;
+    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 DataAggregationResult<DataType, KeyType extends any> = {
+    deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapAggregationValueType<DataType, KeyType>>;
+    aggregateParams: AggregateParams<DataType, KeyType>;
+    initialData: DataType[];
+    reducerResults?: Record<string, AggregationReducerResult>;
+};
+export declare type DeepMapAggregationValueType<DataType, KeyType> = {
+    items: DataType[];
+    commonData?: Partial<DataType>;
+    reducerResults: Record<string, AggregationReducerResult>;
+};
+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

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cumulate = exports.aggregate = void 0;
+const deepMap_1 = require("./deepMap");
+function DEFAULT_TO_KEY(value) {
+    return value;
+}
+function aggregate(aggregateParams, data) {
+    const { groupBy = [], defaultToKey = DEFAULT_TO_KEY, reducers } = aggregateParams;
+    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,
+        aggregateParams,
+        initialData: data,
+        reducerResults: globalReducerResults,
+    };
+    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);
+    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);
+        }
+        initialReducerValue = Object.assign({}, deepMap.get(currentGroupKeys).reducerResults);
+        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,
+    };
+    return result;
+}
+exports.cumulate = cumulate;
+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/Helpers/AdaptableHelper.js

@@ -11,6 +11,8 @@ function assignAdaptableOptions(adaptableOptions) {
     var _a;
     const returnedAdaptableOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions, adaptableOptions);
     returnedAdaptableOptions.adaptableStateKey = (_a = returnedAdaptableOptions.adaptableStateKey) !== null && _a !== void 0 ? _a : returnedAdaptableOptions.adaptableId;
+    returnedAdaptableOptions.adaptableQLOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions, adaptableOptions.adaptableQLOptions);
+    returnedAdaptableOptions.adaptableQLOptions.expressionOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions.expressionOptions, returnedAdaptableOptions.adaptableQLOptions.expressionOptions);
     returnedAdaptableOptions.layoutOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.layoutOptions, adaptableOptions.layoutOptions);
     returnedAdaptableOptions.notificationsOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.notificationsOptions, adaptableOptions.notificationsOptions);
     returnedAdaptableOptions.alertOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.alertOptions, adaptableOptions.alertOptions);
@@ -29,7 +31,6 @@ function assignAdaptableOptions(adaptableOptions) {
     returnedAdaptableOptions.exportOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.exportOptions, adaptableOptions.exportOptions);
     returnedAdaptableOptions.teamSharingOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.teamSharingOptions, adaptableOptions.teamSharingOptions);
     returnedAdaptableOptions.toolPanelOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.toolPanelOptions, adaptableOptions.toolPanelOptions);
-    returnedAdaptableOptions.queryLanguageOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.queryLanguageOptions, adaptableOptions.queryLanguageOptions);
     returnedAdaptableOptions.dataChangeHistoryOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dataChangeHistoryOptions, adaptableOptions.dataChangeHistoryOptions);
     returnedAdaptableOptions.settingsPanelOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.settingsPanelOptions, adaptableOptions.settingsPanelOptions);
     const { predefinedConfig } = returnedAdaptableOptions;