@adaptabletools/adaptable-cjs 18.0.0-canary.8 → 18.0.0-canary.9

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -4,6 +4,7 @@ exports.aggregatedScalarExpressionFunctionNames = exports.aggregatedScalarExpres
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const TypeExtensions_1 = require("../Extensions/TypeExtensions");
+const ArrayExtensions_1 = require("../Extensions/ArrayExtensions");
 exports.aggregatedExpressionFunctions = [
     'SUM',
     'PERCENTAGE',
@@ -14,6 +15,11 @@ exports.aggregatedExpressionFunctions = [
     'WEIGHT',
     'COL',
     'GROUP_BY',
+    'MEDIAN',
+    'MODE',
+    'DISTINCT',
+    'ONLY',
+    'STD_DEVIATION',
 ];
 exports.cumulativeAggregatedExpressionFunctions = [
     'CUMUL',
@@ -80,6 +86,8 @@ exports.aggregatedScalarExpressionFunctions = {
                             field: sumColumnName,
                             initialValue: 0,
                             reducer: (totalSum, rowValue) => {
+                                // TODO: see why error are not concole logged
+                                // debuger = 'Adaptable:*'
                                 if (isUndefinedValue(rowValue)) {
                                     return totalSum;
                                 }
@@ -89,6 +97,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -151,6 +160,7 @@ exports.aggregatedScalarExpressionFunctions = {
                         100);
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByColumnNames, aggregationExpressionEvaluation);
             const result = {
@@ -225,6 +235,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             if (weightParameter) {
@@ -249,6 +260,284 @@ exports.aggregatedScalarExpressionFunctions = {
         examples: ['AVG([colA])', 'AVG([colA], GROUP_BY([colB]))', 'AVG([colA], WEIGHT([colB]))'],
         category: 'aggregation',
     },
+    MEDIAN: {
+        handler(args, context) {
+            const medianColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('MEDIAN', args);
+            const medianColumnName = medianColumnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(medianColumnName, ['Number'], 'MEDIAN', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('MEDIAN', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const getCellValue = (rowNode) => {
+                return context.adaptableApi.gridApi.getNormalisedValueFromRowNode(rowNode, medianColumnName);
+            };
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        MEDIAN: {
+                            name: 'MEDIAN',
+                            field: medianColumnName,
+                            initialValue: [],
+                            reducer: (aggregatedValue, value, rowNode) => {
+                                aggregatedValue.push(rowNode);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                if (aggregatedValue.length === 0) {
+                                    return null;
+                                }
+                                if (aggregatedValue.length === 1) {
+                                    return getCellValue(aggregatedValue[0]);
+                                }
+                                const lenght = aggregatedValue.length;
+                                const middle = Math.floor((lenght - 1) / 2);
+                                if (lenght % 2) {
+                                    return getCellValue(aggregatedValue[middle]);
+                                }
+                                else {
+                                    return ((getCellValue(aggregatedValue[middle]) +
+                                        getCellValue(aggregatedValue[middle + 1])) /
+                                        2.0);
+                                }
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'MEDIAN',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the median of the column values\nOptionally the aggregation may be grouped.',
+        signatures: [
+            'MEDIAN( [colName] )',
+            'MEDIAN( COL(name: string))',
+            'MEDIAN( [colNameA], GROUP_BY( [colNameB] ))',
+            'MEDIAN( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['MEDIAN([colA])', 'MEDIAN([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
+    MODE: {
+        handler(args, context) {
+            const modeColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('mode', args);
+            const modeColumnName = modeColumnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(modeColumnName, ['Number'], 'mode', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('MODE', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        MODE: {
+                            name: 'MODE',
+                            field: modeColumnName,
+                            initialValue: new Map(),
+                            reducer: (aggregatedValue, rowValue, rowNode) => {
+                                var _a;
+                                if (typeof rowValue !== 'number' && typeof rowValue !== 'string') {
+                                    return;
+                                }
+                                aggregatedValue.set(rowValue, ((_a = aggregatedValue.get(rowValue)) !== null && _a !== void 0 ? _a : 0) + 1);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                const sorted = [...aggregatedValue.entries()].sort(([aVal, aFreq], [bVal, bFreq]) => {
+                                    if (aFreq < bFreq) {
+                                        return 1;
+                                    }
+                                    else if (aFreq > bFreq || aVal < bVal) {
+                                        return -1;
+                                    }
+                                    else {
+                                        return aVal === bVal ? 0 : 1;
+                                    }
+                                });
+                                return sorted[0][0];
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'MODE',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the mode of the column values\nOptionally the aggregation may be grouped.',
+        signatures: [
+            'MODE( [colName] )',
+            'MODE( COL(name: string))',
+            'MODE( [colNameA], GROUP_BY( [colNameB] ))',
+            'MODE( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['MODE([colA])', 'MODE([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
+    DISTINCT: {
+        handler(args, context) {
+            const distinctColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('DISTINCT', args);
+            const distinctColumnName = distinctColumnParameter.value;
+            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('MODE', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        DISTINCT: {
+                            name: 'DISTINCT',
+                            field: distinctColumnName,
+                            initialValue: new Set(),
+                            reducer: (aggregatedValue, rowValue, rowNode) => {
+                                if (typeof rowValue !== 'number' && typeof rowValue !== 'string') {
+                                    return aggregatedValue;
+                                }
+                                aggregatedValue.add(rowValue);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                return aggregatedValue.size;
+                            },
+                        },
+                    },
+                },
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'DISTINCT',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the distinct number of the column values\nOptionally the aggregation may be grouped.',
+        signatures: [
+            'DISTINCT( [colName] )',
+            'DISTINCT( COL(name: string))',
+            'DISTINCT( [colNameA], GROUP_BY( [colNameB] ))',
+            'DISTINCT( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['DISTINCT([colA])', 'DISTINCT([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
+    ONLY: {
+        handler(args, context) {
+            const distinctColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('ONLY', args);
+            const onlyColumnName = distinctColumnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(onlyColumnName, ['Number'], 'ONLY', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('ONLY', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        ONLY: {
+                            name: 'ONLY',
+                            field: onlyColumnName,
+                            initialValue: new Set(),
+                            reducer: (aggregatedValue, rowValue, rowNode) => {
+                                if (typeof rowValue !== 'number' && typeof rowValue !== 'string') {
+                                    return aggregatedValue;
+                                }
+                                aggregatedValue.add(rowValue);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                return aggregatedValue.size === 1 ? aggregatedValue.values().next().value : null;
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'ONLY',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing to a value that is common to all rows. \nOptionally the aggregation may be grouped.',
+        signatures: [
+            'ONLY( [colName] )',
+            'ONLY( COL(name: string))',
+            'ONLY( [colNameA], GROUP_BY( [colNameB] ))',
+            'ONLY( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['ONLY([colA])', 'ONLY([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
+    STD_DEVIATION: {
+        handler(args, context) {
+            const columnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('STD_DEVIATION', args);
+            const columnName = columnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(columnName, ['Number'], 'STD_DEVIATION', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('STD_DEVIATION', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        STD_DEVIATION: {
+                            name: 'STD_DEVIATION',
+                            field: columnName,
+                            initialValue: { sumOfValues: 0, values: [] },
+                            reducer: (aggregatedValue, rowValue, rowNode) => {
+                                // TODO: getNumericValue; allow numeric strings
+                                if (typeof rowValue !== 'number' || isNaN(rowValue)) {
+                                    return aggregatedValue;
+                                }
+                                aggregatedValue.sumOfValues = aggregatedValue.sumOfValues + rowValue;
+                                aggregatedValue.values.push(rowValue);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                const { sumOfValues, values } = aggregatedValue;
+                                if (values.length === 0) {
+                                    return 0;
+                                }
+                                const mean = sumOfValues / values.length;
+                                const variance = (0, ArrayExtensions_1.SumArray)(values.map((value) => Math.pow(value - mean, 2))) / values.length;
+                                return Math.sqrt(variance);
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'STD_DEVIATION',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing to a value that is common to all rows. \nOptionally the aggregation may be grouped.',
+        signatures: [
+            'ONLY( [colName] )',
+            'ONLY( COL(name: string))',
+            'ONLY( [colNameA], GROUP_BY( [colNameB] ))',
+            'ONLY( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['ONLY([colA])', 'ONLY([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
     MIN: {
         handler(args, context) {
             const minColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('MIN', args);
@@ -280,6 +569,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -330,6 +620,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -448,6 +739,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
                     return isDefinedValue(rowValue);
                 },
+                getRowNodes: context.getRowNodes,
                 aggregationParams: {
                     reducers: {
                         QUANT: Object.assign({ name: 'QUANT', field: quantileColumnName }, quantReducer),
@@ -526,6 +818,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -748,6 +1041,7 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
         },
         rowValueGetter,
         rowFilterFn: aggregationEvaluation.rowFilterFn,
+        getRowNodes: context.getRowNodes,
     };
     return cumulationExpressionEvaluation;
 };

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -11,7 +11,7 @@ function aggregate(aggregateParams, data) {
     const deepMap = new deepMap_1.DeepMap();
     let currentGroupKeys = [];
     const getInitialReducerValue = () => {
-        return JSON.parse(JSON.stringify(initReducers(reducers)));
+        return structuredClone(initReducers(reducers));
     };
     const globalReducerResults = getInitialReducerValue();
     for (let i = 0, len = data.length; i < len; i++) {

package/src/Utilities/Extensions/ArrayExtensions.d.ts

@@ -32,6 +32,7 @@ export declare function sortCellValueArrayNumeric(cellValues: GridCell[], sortOr
 export declare function sortCellValueArrayDates(cellValues: GridCell[], sortOrder?: SortOrder): GridCell[];
 export declare function groupArrayBy(array: Array<any>, prop: string): Array<any>;
 export declare function createCommaSeparatedString(values: any[]): string;
+export declare function SumArray(array: (number | undefined)[]): number;
 export declare const ArrayExtensions: {
     GetLength: typeof GetLength;
     CorrectLength: typeof CorrectLength;
@@ -65,5 +66,6 @@ export declare const ArrayExtensions: {
     sortCellValueArrayDates: typeof sortCellValueArrayDates;
     sortArrayWithProperty: typeof sortArrayWithProperty;
     createCommaSeparatedString: typeof createCommaSeparatedString;
+    SumArray: typeof SumArray;
 };
 export default ArrayExtensions;

package/src/Utilities/Extensions/ArrayExtensions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayExtensions = exports.createCommaSeparatedString = exports.groupArrayBy = exports.sortCellValueArrayDates = exports.sortCellValueArrayNumeric = exports.sortCellValueArray = exports.sortArray = exports.sortArrayWithProperty = exports.areArraysEqualWithOrderandProperties = exports.areArraysEqualWithOrder = exports.areArraysNotEqual = exports.areArraysEqual = exports.moveArray = exports.hasItemsOfCount = exports.hasOneItem = exports.getOccurrence = exports.HasSingleEmptyValue = exports.IsNotNullOrEmptyNorContainsSingleEmptyValue = exports.IsNullOrEmptyOrContainsSingleEmptyValue = exports.IsNotNullOrEmpty = exports.IsNullOrEmpty = exports.IsNotEmpty = exports.IsEmpty = exports.IsNotNull = exports.IsNull = exports.RetrieveDistinct = exports.NotContainsItem = exports.ContainsAnyItem = exports.ContainsItem = exports.AddItem = exports.NotCorrectLength = exports.CorrectLength = exports.GetLength = void 0;
+exports.ArrayExtensions = exports.SumArray = exports.createCommaSeparatedString = exports.groupArrayBy = exports.sortCellValueArrayDates = exports.sortCellValueArrayNumeric = exports.sortCellValueArray = exports.sortArray = exports.sortArrayWithProperty = exports.areArraysEqualWithOrderandProperties = exports.areArraysEqualWithOrder = exports.areArraysNotEqual = exports.areArraysEqual = exports.moveArray = exports.hasItemsOfCount = exports.hasOneItem = exports.getOccurrence = exports.HasSingleEmptyValue = exports.IsNotNullOrEmptyNorContainsSingleEmptyValue = exports.IsNullOrEmptyOrContainsSingleEmptyValue = exports.IsNotNullOrEmpty = exports.IsNullOrEmpty = exports.IsNotEmpty = exports.IsEmpty = exports.IsNotNull = exports.IsNull = exports.RetrieveDistinct = exports.NotContainsItem = exports.ContainsAnyItem = exports.ContainsItem = exports.AddItem = exports.NotCorrectLength = exports.CorrectLength = exports.GetLength = void 0;
 const Enums_1 = require("../../PredefinedConfig/Common/Enums");
 function GetLength(arrayToCheck) {
     return IsNotNull(arrayToCheck) ? arrayToCheck.length : 0;
@@ -289,6 +289,10 @@ function createCommaSeparatedString(values) {
     return values.join(', ');
 }
 exports.createCommaSeparatedString = createCommaSeparatedString;
+function SumArray(array) {
+    return array.filter((num) => typeof num === 'number' && !isNaN(num)).reduce((a, b) => a + b, 0);
+}
+exports.SumArray = SumArray;
 exports.ArrayExtensions = {
     GetLength,
     CorrectLength,
@@ -322,5 +326,6 @@ exports.ArrayExtensions = {
     sortCellValueArrayDates,
     sortArrayWithProperty,
     createCommaSeparatedString,
+    SumArray,
 };
 exports.default = exports.ArrayExtensions;

package/src/Utilities/ObjectFactory.js

@@ -33,10 +33,10 @@ function CreateEmptyCalculatedColumn() {
         // need to create some defaults - which we will change later
         CalculatedColumnSettings: {
             DataType: undefined,
-            Filterable: false,
-            Resizable: false,
+            Filterable: true,
+            Resizable: true,
             Groupable: false,
-            Sortable: false,
+            Sortable: true,
             Pivotable: false,
             Aggregatable: false,
             SuppressMenu: false,
@@ -282,10 +282,10 @@ function CreateEmptyFreeTextColumn() {
         TextEditor: 'Inline',
         FreeTextColumnSettings: {
             DataType: 'String',
-            Filterable: false,
-            Resizable: false,
+            Filterable: true,
+            Resizable: true,
             Groupable: false,
-            Sortable: false,
+            Sortable: true,
             Pivotable: false,
             Aggregatable: false,
             SuppressMenu: false,

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

@@ -7,6 +7,7 @@ export declare class AggregatedScalarLiveValue {
     private source;
     private requestingModule;
     private adaptableApi;
+    private getRowNodes?;
     private aggregationReducerName;
     private aggregatedScalarExpression;
     private expressionEvaluation;
@@ -15,11 +16,11 @@ export declare class AggregatedScalarLiveValue {
         aggregatedScalarExpression: string;
     }, {
         aggregatedScalarExpressionEvaluation: AggregatedScalarExpressionEvaluation;
-    }>, requestingModule: ModuleConstants, adaptableApi: AdaptableApi);
+    }>, requestingModule: ModuleConstants, adaptableApi: AdaptableApi, getRowNodes?: () => IRowNode[]);
     refresh(): void;
     getAggregatedValueForRow(rowNode: IRowNode): any;
     getAllAggregationValues(): number[];
     private getAggregationValue;
-    private getGlobalAggregatedValue;
+    getGlobalAggregatedValue(): any;
     private computeAggregatedValue;
 }

package/src/Utilities/Services/AggregatedScalarLiveValue.js

@@ -11,18 +11,18 @@ const logOnce = (message, loggingFn) => {
     doOnceFlags[message] = true;
 };
 class AggregatedScalarLiveValue {
-    constructor(source, requestingModule, adaptableApi) {
+    constructor(source, requestingModule, adaptableApi, getRowNodes) {
         this.source = source;
         this.requestingModule = requestingModule;
         this.adaptableApi = adaptableApi;
+        this.getRowNodes = getRowNodes;
         if (source.aggregatedScalarExpression) {
             this.aggregatedScalarExpression = source.aggregatedScalarExpression;
         }
         this.expressionEvaluation = source.aggregatedScalarExpression
             ? this.adaptableApi.internalApi
                 .getQueryLanguageService()
-                .evaluateAggregatedScalarExpression(source.aggregatedScalarExpression, requestingModule)
-                .value
+                .evaluateAggregatedScalarExpression(source.aggregatedScalarExpression, requestingModule, getRowNodes).value
             : source.aggregatedScalarExpressionEvaluation;
         // currently we support only one reducer
         this.aggregationReducerName = Object.keys(this.expressionEvaluation.aggregationParams.reducers)[0];
@@ -32,7 +32,7 @@ class AggregatedScalarLiveValue {
         if (this.aggregatedScalarExpression) {
             this.expressionEvaluation = this.adaptableApi.internalApi
                 .getQueryLanguageService()
-                .evaluateAggregatedScalarExpression(this.aggregatedScalarExpression, this.requestingModule).value;
+                .evaluateAggregatedScalarExpression(this.aggregatedScalarExpression, this.requestingModule, this.getRowNodes).value;
         }
         // currently we support only one reducer
         this.aggregationReducerName = Object.keys(this.expressionEvaluation.aggregationParams.reducers)[0];
@@ -73,9 +73,11 @@ class AggregatedScalarLiveValue {
     }
     computeAggregatedValue(expressionEvaluation) {
         var _a;
-        const gridRowNodes = this.adaptableApi.gridApi.getAllRowNodes({
-            filterFn: expressionEvaluation.rowFilterFn,
-        });
+        const gridRowNodes = expressionEvaluation.getRowNodes
+            ? expressionEvaluation.getRowNodes()
+            : 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) => {
@@ -111,7 +113,8 @@ class AggregatedScalarLiveValue {
                 return 0;
             });
         }
-        return (0, scalarAggregationHelper_1.aggregate)(expressionEvaluation.aggregationParams, aggregatedRowNodes);
+        const result = (0, scalarAggregationHelper_1.aggregate)(expressionEvaluation.aggregationParams, aggregatedRowNodes);
+        return result;
     }
 }
 exports.AggregatedScalarLiveValue = AggregatedScalarLiveValue;

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

@@ -15,7 +15,7 @@ export interface IQueryLanguageService extends IAdaptableService {
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
     evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo | GridDataChangedInfo>;
     evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): BooleanAggregationParameter;
-    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): ScalarAggregationParameter;
+    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule, getRowNodes?: () => IRowNode[]): ScalarAggregationParameter;
     validateBoolean(expression: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {

package/src/Utilities/Services/LicenseService/index.js

@@ -48,7 +48,10 @@ class LicenseService {
         this.packageDetails = packageDetails;
         this.adaptable = adaptable;
         this.adaptable.api.eventApi.on('AdaptableReady', () => {
-            this.init();
+            requestAnimationFrame(() => {
+                // using a rAF because we want to make sure that the window.location.origin is available (Master/Detail is fidgity sometimes)
+                this.init();
+            });
         });
     }
     init() {

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

@@ -16,7 +16,7 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     constructor(adaptableApi: AdaptableApi);
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
-    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): ScalarAggregationParameter;
+    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule, getRowNodes?: () => IRowNode[]): ScalarAggregationParameter;
     evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo | GridDataChangedInfo>;
     evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): BooleanAggregationParameter;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {

package/src/Utilities/Services/QueryLanguageService.js

@@ -36,7 +36,7 @@ class QueryLanguageService {
         // currently scalar and boolean expressions are evaluated the same
         return this.evaluateBooleanExpression(expression, module, rowNode);
     }
-    evaluateAggregatedScalarExpression(expression, module) {
+    evaluateAggregatedScalarExpression(expression, module, getRowNodes) {
         const aggregatedScalarFunctions = this.getModuleExpressionFunctionsMap(module).aggregatedScalarFunctions;
         return parser.evaluate(expression, {
             node: null,
@@ -45,6 +45,7 @@ class QueryLanguageService {
             adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
             functions: aggregatedScalarFunctions,
             evaluateCustomQueryVariable: this.evaluateCustomQueryVariable,
+            getRowNodes,
         });
     }
     evaluateObservableExpression(reactiveExpression, module) {

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

@@ -0,0 +1,19 @@
+import { IRowNode } from '@ag-grid-community/core';
+import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
+import { AdaptableApi, AdaptableModule } from '../../types';
+export declare const summarySupportedExpressions: readonly ["SUM", "AVG", "MIN", "MAX", "COUNT", "MEDIAN", "MODE", "DISTINCT", "ONLY", "STD_DEVIATION"];
+export type SummarySupportedExpression = (typeof summarySupportedExpressions)[number];
+export type SumaryConfig = {
+    expression: {
+        function: SummarySupportedExpression;
+    };
+    columnId: string;
+    getRowNodes?: () => IRowNode[];
+};
+export declare class SummaryService {
+    private adaptableApi;
+    constructor(adaptableApi: AdaptableApi);
+    evaluateExpressionValue(config: SumaryConfig, moduleId: AdaptableModule): any;
+    evaluateScalarLiveValue(config: SumaryConfig, moduleId: AdaptableModule): AggregatedScalarLiveValue;
+    destroy(): void;
+}

package/src/Utilities/Services/SummaryService.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SummaryService = exports.summarySupportedExpressions = void 0;
+const AggregatedScalarLiveValue_1 = require("./AggregatedScalarLiveValue");
+exports.summarySupportedExpressions = [
+    'SUM',
+    'AVG',
+    'MIN',
+    'MAX',
+    'COUNT',
+    'MEDIAN',
+    'MODE',
+    'DISTINCT',
+    'ONLY',
+    'STD_DEVIATION',
+];
+class SummaryService {
+    constructor(adaptableApi) {
+        this.adaptableApi = adaptableApi;
+    }
+    evaluateExpressionValue(config, moduleId) {
+        return this.evaluateScalarLiveValue(config, moduleId).getGlobalAggregatedValue();
+    }
+    evaluateScalarLiveValue(config, moduleId) {
+        return new AggregatedScalarLiveValue_1.AggregatedScalarLiveValue({
+            aggregatedScalarExpression: `${config.expression.function}([${config.columnId}])`,
+        }, moduleId, this.adaptableApi, config.getRowNodes);
+    }
+    destroy() {
+        this.adaptableApi = null;
+    }
+}
+exports.SummaryService = SummaryService;