@adaptabletools/adaptable 18.0.0-canary.8 → 18.0.0

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -1,6 +1,9 @@
-import { extractColumnParameter, extractColumnParameters, extractParameter, getNumericValue, handleColumnFunction, validateColumnType, } from './expressionFunctionUtils';
 import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
+import { SumArray } from '../Extensions/ArrayExtensions';
 import { getTypedKeys } from '../Extensions/TypeExtensions';
+import { extractColumnParameter, extractColumnParameters, extractParameter, getNumericValue, handleColumnFunction, validateColumnType, } from './expressionFunctionUtils';
+import isAfter from 'date-fns/isAfter';
+import { parseDateValue } from '../Helpers/DateHelper';
 export const aggregatedExpressionFunctions = [
     'SUM',
     'PERCENTAGE',
@@ -11,6 +14,11 @@ export const aggregatedExpressionFunctions = [
     'WEIGHT',
     'COL',
     'GROUP_BY',
+    'MEDIAN',
+    'MODE',
+    'DISTINCT',
+    'ONLY',
+    'STD_DEVIATION',
 ];
 export const cumulativeAggregatedExpressionFunctions = [
     'CUMUL',
@@ -77,6 +85,8 @@ export const aggregatedScalarExpressionFunctions = {
                             field: sumColumnName,
                             initialValue: 0,
                             reducer: (totalSum, rowValue) => {
+                                // TODO: see why error are not concole logged
+                                // debuger = 'Adaptable:*'
                                 if (isUndefinedValue(rowValue)) {
                                     return totalSum;
                                 }
@@ -86,6 +96,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -104,6 +115,7 @@ export const aggregatedScalarExpressionFunctions = {
         ],
         examples: ['SUM([colA])', 'SUM([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
     },
     PERCENTAGE: {
         handler(args, context) {
@@ -148,6 +160,7 @@ export const aggregatedScalarExpressionFunctions = {
                         100);
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByColumnNames, aggregationExpressionEvaluation);
             const result = {
@@ -222,6 +235,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             if (weightParameter) {
@@ -245,6 +259,294 @@ export const aggregatedScalarExpressionFunctions = {
         ],
         examples: ['AVG([colA])', 'AVG([colA], GROUP_BY([colB]))', 'AVG([colA], WEIGHT([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
+    },
+    MEDIAN: {
+        handler(args, context) {
+            const medianColumnParameter = extractColumnParameter('MEDIAN', args);
+            const medianColumnName = medianColumnParameter.value;
+            validateColumnType(medianColumnName, ['Number'], 'MEDIAN', context.adaptableApi);
+            const groupByParameter = 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',
+        inputs: ['number'],
+    },
+    MODE: {
+        handler(args, context) {
+            const modeColumnParameter = extractColumnParameter('mode', args);
+            const modeColumnName = modeColumnParameter.value;
+            validateColumnType(modeColumnName, ['Number', 'String', 'Date'], 'mode', context.adaptableApi);
+            const groupByParameter = 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;
+                                }
+                                if (!aggregatedValue) {
+                                    return new Map();
+                                }
+                                aggregatedValue.set(rowValue, ((_a = aggregatedValue.get(rowValue)) !== null && _a !== void 0 ? _a : 0) + 1);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                var _a;
+                                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 (_a = sorted === null || sorted === void 0 ? void 0 : sorted[0]) === null || _a === void 0 ? void 0 : _a[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',
+        inputs: [['number'], ['text'], ['date']],
+    },
+    DISTINCT: {
+        handler(args, context) {
+            const distinctColumnParameter = extractColumnParameter('DISTINCT', args);
+            const distinctColumnName = distinctColumnParameter.value;
+            const groupByParameter = 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',
+        inputs: [['number'], ['text'], ['date']],
+    },
+    ONLY: {
+        handler(args, context) {
+            const distinctColumnParameter = extractColumnParameter('ONLY', args);
+            const onlyColumnName = distinctColumnParameter.value;
+            validateColumnType(onlyColumnName, ['Number'], 'ONLY', context.adaptableApi);
+            const groupByParameter = 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',
+        inputs: [['number'], ['text'], ['date']],
+    },
+    STD_DEVIATION: {
+        handler(args, context) {
+            const columnParameter = extractColumnParameter('STD_DEVIATION', args);
+            const columnName = columnParameter.value;
+            validateColumnType(columnName, ['Number'], 'STD_DEVIATION', context.adaptableApi);
+            const groupByParameter = 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 = 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',
+        inputs: ['number'],
     },
     MIN: {
         handler(args, context) {
@@ -277,6 +579,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -295,6 +598,7 @@ export const aggregatedScalarExpressionFunctions = {
         ],
         examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
     },
     MAX: {
         handler(args, context) {
@@ -327,6 +631,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -345,6 +650,7 @@ export const aggregatedScalarExpressionFunctions = {
         ],
         examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
     },
     QUANT: {
         handler(args, context) {
@@ -445,6 +751,7 @@ export const 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),
@@ -523,6 +830,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -541,6 +849,7 @@ export const aggregatedScalarExpressionFunctions = {
         ],
         examples: ['COUNT([colA])', 'COUNT([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: [['number'], ['text'], ['date']],
     },
     OVER: {
         handler(args, context) {
@@ -602,6 +911,124 @@ export const aggregatedScalarExpressionFunctions = {
         examples: ['[col1]', 'COL("col1")'],
         category: 'special',
     },
+    OLDEST: {
+        handler(args, context) {
+            const minColumnParameter = extractColumnParameter('OLDEST', args);
+            const minColumnName = minColumnParameter.value;
+            validateColumnType(minColumnName, ['Date'], 'OLDEST', context.adaptableApi);
+            const groupByParameter = extractParameter('OLDEST', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        OLDEST: {
+                            name: 'OLDEST',
+                            field: minColumnName,
+                            initialValue: null,
+                            reducer: (minValue, rowValue) => {
+                                if (!minValue) {
+                                    return rowValue;
+                                }
+                                if (!rowValue) {
+                                    return minValue;
+                                }
+                                if (isAfter(parseDateValue(minValue), parseDateValue(rowValue))) {
+                                    return rowValue;
+                                }
+                                else {
+                                    return minValue;
+                                }
+                            },
+                            done: (minValue, arr) => {
+                                if (minValue !== null) {
+                                    return minValue;
+                                }
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'OLDEST',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a Date column over multiple rows by computing the oldest of the column values\nOptionally the aggregation may be computed within provided individual groups',
+        signatures: [
+            'OLDEST( [colName] )',
+            'OLDEST( COL(name: string))',
+            'OLDEST( [colNameA], GROUP_BY( [colNameB] ))',
+            'OLDEST( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['OLDEST([colA])', 'OLDEST([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+        inputs: ['date'],
+    },
+    NEWEST: {
+        handler(args, context) {
+            const minColumnParameter = extractColumnParameter('NEWEST', args);
+            const minColumnName = minColumnParameter.value;
+            validateColumnType(minColumnName, ['Date'], 'NEWEST', context.adaptableApi);
+            const groupByParameter = extractParameter('NEWEST', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        NEWEST: {
+                            name: 'NEWEST',
+                            field: minColumnName,
+                            initialValue: null,
+                            reducer: (minValue, rowValue) => {
+                                if (!minValue) {
+                                    return rowValue;
+                                }
+                                if (!rowValue) {
+                                    return minValue;
+                                }
+                                if (isAfter(parseDateValue(minValue), parseDateValue(rowValue))) {
+                                    return minValue;
+                                }
+                                else {
+                                    return rowValue;
+                                }
+                            },
+                            done: (minValue, arr) => {
+                                if (minValue !== null) {
+                                    return minValue;
+                                }
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'NEWEST',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a Date column over multiple rows by computing the most recent of the column values\nOptionally the aggregation may be computed within provided individual groups',
+        signatures: [
+            'NEWEST( [colName] )',
+            'NEWEST( COL(name: string))',
+            'NEWEST( [colNameA], GROUP_BY( [colNameB] ))',
+            'NEWEST( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['NEWEST([colA])', 'NEWEST([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+        inputs: ['date'],
+    },
 };
 const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, context) => {
     const aggregationEvaluation = aggregationParameter.value;
@@ -673,13 +1100,15 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
                                 if ((_a = aggregationEvaluation.context) === null || _a === void 0 ? void 0 : _a.weightParam) {
                                     // weighted average
                                     const weightValue = (_b = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, aggregationEvaluation.context.weightParam.value)) !== null && _b !== void 0 ? _b : 0;
-                                    cumulationBag.currentValue = cumulationBag.currentValue + rowValue * weightValue;
+                                    cumulationBag.currentValue =
+                                        cumulationBag.currentValue + rowValue * weightValue;
                                     cumulationBag.numberOfCumulatedValues =
                                         cumulationBag.numberOfCumulatedValues + weightValue;
                                 }
                                 else {
                                     cumulationBag.currentValue = cumulationBag.currentValue + rowValue;
-                                    cumulationBag.numberOfCumulatedValues = cumulationBag.numberOfCumulatedValues + 1;
+                                    cumulationBag.numberOfCumulatedValues =
+                                        cumulationBag.numberOfCumulatedValues + 1;
                                 }
                             }
                             if (cumulationBag.numberOfCumulatedValues !== 0) {
@@ -745,6 +1174,7 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
         },
         rowValueGetter,
         rowFilterFn: aggregationEvaluation.rowFilterFn,
+        getRowNodes: context.getRowNodes,
     };
     return cumulationExpressionEvaluation;
 };

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -275,10 +275,10 @@ const isLastElementMinValue = (values) => {
 };
 // useful for functions which do NOT have an initial change (ex. GRID_CHANGE NONE)
 const getDataChangedInfoStub = (context) => {
-    var _a;
+    var _a, _b;
     let rowNodeStub;
     if (!context.filterFn) {
-        rowNodeStub = context.adaptableApi.gridApi.getFirstRowNode();
+        rowNodeStub = (_a = context.node) !== null && _a !== void 0 ? _a : context.adaptableApi.gridApi.getFirstRowNode();
     }
     else {
         // if there is a WHERE clause defined, find the first rowNode which satisfies the condition
@@ -293,7 +293,7 @@ const getDataChangedInfoStub = (context) => {
     const rowNode = rowNodeStub;
     if (rowNode) {
         const primaryKeyValue = context.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(rowNode);
-        const columnId = (_a = context.adaptableApi.columnApi.getQueryableColumns()[0]) === null || _a === void 0 ? void 0 : _a.columnId;
+        const columnId = (_b = context.adaptableApi.columnApi.getQueryableColumns()[0]) === null || _b === void 0 ? void 0 : _b.columnId;
         const oldValue = context.adaptableApi.gridApi.getCellRawValue(primaryKeyValue, columnId);
         const column = context.adaptableApi.columnApi.getColumnWithColumnId(columnId);
         const newValue = oldValue;

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -8,7 +8,7 @@ export function aggregate(aggregateParams, data) {
     const deepMap = new 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/ExpressionFunctions/scalarExpressionFunctions.d.ts

@@ -2,6 +2,6 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Scalar Functions available in AdaptableQL
  */
-export type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'ABS' | 'CEILING' | 'FLOOR' | 'ROUND' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'CURRENT_DAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'NULL' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'CASE' | 'COL' | 'VAR' | 'TO_ARRAY' | 'QUERY' | 'IS_BLANK' | 'IS_NOT_BLANK';
+export type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'ABS' | 'CEILING' | 'FLOOR' | 'ROUND' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'CURRENT_DAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'NULL' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'CASE' | 'COL' | 'FIELD' | 'VAR' | 'TO_ARRAY' | 'QUERY' | 'IS_BLANK' | 'IS_NOT_BLANK';
 export declare const scalarExpressionFunctions: Record<ScalarFunctionName, ExpressionFunction>;
 export declare const scalarExpressionFunctionNames: ScalarFunctionName[];

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -68,6 +68,21 @@ export const scalarExpressionFunctions = {
         category: 'special',
         returnType: 'any',
     },
+    FIELD: {
+        handler(args, context) {
+            var _a, _b;
+            const fieldName = args[0];
+            if (StringExtensions.IsNullOrEmpty(fieldName)) {
+                throw new ExpressionEvaluationError('FIELD', 'requires a field name');
+            }
+            return (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.internalApi.getValueUsingField((_b = context.node) === null || _b === void 0 ? void 0 : _b.data, fieldName);
+        },
+        description: 'Returns the value of a row field (not necessarily mapped to a column). If the field is nested, use dot notation (e.g. "nested.fieldName")',
+        signatures: ['FIELD(fieldName:string)'],
+        examples: ['FIELD("fieldName")', 'FIELD("nested.fieldName")'],
+        category: 'special',
+        returnType: 'any',
+    },
     QUERY: {
         handler(args, context) {
             var _a, _b;

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

@@ -254,6 +254,9 @@ export function groupArrayBy(array, prop) {
 export function createCommaSeparatedString(values) {
     return values.join(', ');
 }
+export function SumArray(array) {
+    return array.filter((num) => typeof num === 'number' && !isNaN(num)).reduce((a, b) => a + b, 0);
+}
 export const ArrayExtensions = {
     GetLength,
     CorrectLength,
@@ -287,5 +290,6 @@ export const ArrayExtensions = {
     sortCellValueArrayDates,
     sortArrayWithProperty,
     createCommaSeparatedString,
+    SumArray,
 };
 export default ArrayExtensions;