@adaptabletools/adaptable 19.2.3 → 20.0.0-canary.0

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -19,6 +19,12 @@ export const aggregatedExpressionFunctions = [
     'DISTINCT',
     'ONLY',
     'STD_DEVIATION',
+    'PREVIOUS',
+    'NEXT',
+    'FIRST',
+    'LAST',
+    'ABSOLUTE_DIFF',
+    'PERCENT_DIFF',
 ];
 export const cumulativeAggregatedExpressionFunctions = [
     'CUMUL',
@@ -27,10 +33,17 @@ export const cumulativeAggregatedExpressionFunctions = [
     'PERCENTAGE',
     'MIN',
     'MAX',
+    'QUANT',
+    'PREVIOUS',
+    'NEXT',
+    'FIRST',
+    'LAST',
     'AVG',
     'WEIGHT',
     'COL',
     'GROUP_BY',
+    'ABSOLUTE_DIFF',
+    'PERCENT_DIFF',
 ];
 export const quantileAggregatedExpressionFunctions = [
     'QUANT',
@@ -73,7 +86,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const sumColumnParameter = extractColumnParameter('SUM', args);
             const sumColumnName = sumColumnParameter.value;
-            const columnType = validateColumnType(sumColumnName, ['Number'], 'SUM', context.adaptableApi);
+            const columnType = validateColumnType(sumColumnName, ['number'], 'SUM', context.adaptableApi);
             const groupByParameter = extractParameter('SUM', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -85,8 +98,6 @@ 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;
                                 }
@@ -99,7 +110,7 @@ export const aggregatedScalarExpressionFunctions = {
                 getRowNodes: context.getRowNodes,
                 columnType,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'SUM',
                 type: 'aggregationScalar',
@@ -120,10 +131,9 @@ export const aggregatedScalarExpressionFunctions = {
     },
     PERCENTAGE: {
         handler(args, context) {
-            var _a;
             const percentageColumnParameter = extractColumnParameter('PERCENTAGE', args);
             const percentageColumnName = percentageColumnParameter.value;
-            const columnType = validateColumnType(percentageColumnName, ['Number'], 'PERCENTAGE', context.adaptableApi);
+            const columnType = validateColumnType(percentageColumnName, ['number'], 'PERCENTAGE', context.adaptableApi);
             const sumOperand = extractParameter('PERCENTAGE', 'aggregationScalar', ['SUM'], args, {
                 isOptional: true,
             });
@@ -137,8 +147,8 @@ export const aggregatedScalarExpressionFunctions = {
                 ? sumOperand.value.aggregationParams.reducers['SUM'].field
                 : percentageColumnName;
             const groupByColumnNames = groupByOperand
-                ? groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value
-                : (_a = sumOperand === null || sumOperand === void 0 ? void 0 : sumOperand.value.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.map((param) => param.field);
+                ? groupByOperand?.value
+                : sumOperand?.value.aggregationParams.groupBy?.map((param) => param.field);
             const aggregationExpressionEvaluation = {
                 aggregationParams: {
                     reducers: {
@@ -191,7 +201,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const avgColumnParameter = extractColumnParameter('AVG', args);
             const avgColumnName = avgColumnParameter.value;
-            const columnType = validateColumnType(avgColumnName, ['Number'], 'AVG', context.adaptableApi);
+            const columnType = validateColumnType(avgColumnName, ['number'], 'AVG', context.adaptableApi);
             const groupByParameter = extractParameter('AVG', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -209,14 +219,13 @@ export const aggregatedScalarExpressionFunctions = {
                                 numberOfValues: 0,
                             },
                             reducer: (aggregatedValue, rowValue, rowNode) => {
-                                var _a;
                                 if (isUndefinedValue(rowValue)) {
                                     return aggregatedValue;
                                 }
                                 const numericRowValue = getNumericValue(rowValue);
                                 if (weightParameter) {
                                     // weighted average
-                                    const weightValue = (_a = getNumericValue(context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, weightParameter.value))) !== null && _a !== void 0 ? _a : 0;
+                                    const weightValue = getNumericValue(context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, weightParameter.value)) ?? 0;
                                     aggregatedValue.sumOfValues =
                                         aggregatedValue.sumOfValues + numericRowValue * weightValue;
                                     aggregatedValue.numberOfValues = aggregatedValue.numberOfValues + weightValue;
@@ -240,7 +249,7 @@ export const aggregatedScalarExpressionFunctions = {
                 getRowNodes: context.getRowNodes,
                 columnType,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             if (weightParameter) {
                 aggregationExpressionEvaluation.context = {
                     weightParam: weightParameter,
@@ -268,13 +277,10 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const medianColumnParameter = extractColumnParameter('MEDIAN', args);
             const medianColumnName = medianColumnParameter.value;
-            const columnType = validateColumnType(medianColumnName, ['Number'], 'MEDIAN', context.adaptableApi);
+            const columnType = 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: {
@@ -282,8 +288,8 @@ export const aggregatedScalarExpressionFunctions = {
                             name: 'MEDIAN',
                             field: medianColumnName,
                             initialValue: [],
-                            reducer: (aggregatedValue, value, rowNode) => {
-                                aggregatedValue.push(rowNode);
+                            reducer: (aggregatedValue, cellValue) => {
+                                aggregatedValue.push(getNumericValue(cellValue));
                                 return aggregatedValue;
                             },
                             done: (aggregatedValue) => {
@@ -291,17 +297,15 @@ export const aggregatedScalarExpressionFunctions = {
                                     return null;
                                 }
                                 if (aggregatedValue.length === 1) {
-                                    return getCellValue(aggregatedValue[0]);
+                                    return aggregatedValue[0];
                                 }
-                                const lenght = aggregatedValue.length;
-                                const middle = Math.floor((lenght - 1) / 2);
-                                if (lenght % 2) {
-                                    return getCellValue(aggregatedValue[middle]);
+                                const length = aggregatedValue.length;
+                                const middle = Math.floor((length - 1) / 2);
+                                if (length % 2) {
+                                    return aggregatedValue[middle];
                                 }
                                 else {
-                                    return ((getCellValue(aggregatedValue[middle]) +
-                                        getCellValue(aggregatedValue[middle + 1])) /
-                                        2.0);
+                                    return (aggregatedValue[middle] + aggregatedValue[middle + 1]) / 2.0;
                                 }
                             },
                         },
@@ -311,7 +315,7 @@ export const aggregatedScalarExpressionFunctions = {
                 getRowNodes: context.getRowNodes,
                 columnType,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'MEDIAN',
                 type: 'aggregationScalar',
@@ -334,7 +338,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const modeColumnParameter = extractColumnParameter('mode', args);
             const modeColumnName = modeColumnParameter.value;
-            const columnType = validateColumnType(modeColumnName, ['Number', 'String', 'Date'], 'mode', context.adaptableApi);
+            const columnType = validateColumnType(modeColumnName, ['number', 'text', 'date'], 'mode', context.adaptableApi);
             const groupByParameter = extractParameter('MODE', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -345,19 +349,17 @@ export const aggregatedScalarExpressionFunctions = {
                             name: 'MODE',
                             field: modeColumnName,
                             initialValue: new Map(),
-                            reducer: (aggregatedValue, rowValue, rowNode) => {
-                                var _a;
+                            reducer: (aggregatedValue, rowValue) => {
                                 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);
+                                aggregatedValue.set(rowValue, (aggregatedValue.get(rowValue) ?? 0) + 1);
                                 return aggregatedValue;
                             },
                             done: (aggregatedValue) => {
-                                var _a;
                                 const sorted = [...aggregatedValue.entries()].sort(([aVal, aFreq], [bVal, bFreq]) => {
                                     if (aFreq < bFreq) {
                                         return 1;
@@ -369,7 +371,7 @@ export const aggregatedScalarExpressionFunctions = {
                                         return aVal === bVal ? 0 : 1;
                                     }
                                 });
-                                return (_a = sorted === null || sorted === void 0 ? void 0 : sorted[0]) === null || _a === void 0 ? void 0 : _a[0];
+                                return sorted?.[0]?.[0];
                             },
                         },
                     },
@@ -378,7 +380,7 @@ export const aggregatedScalarExpressionFunctions = {
                 getRowNodes: context.getRowNodes,
                 columnType,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'MODE',
                 type: 'aggregationScalar',
@@ -426,7 +428,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 getRowNodes: context.getRowNodes,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'DISTINCT',
                 type: 'aggregationScalar',
@@ -449,7 +451,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const distinctColumnParameter = extractColumnParameter('ONLY', args);
             const onlyColumnName = distinctColumnParameter.value;
-            const columnType = validateColumnType(onlyColumnName, ['Number'], 'ONLY', context.adaptableApi);
+            const columnType = validateColumnType(onlyColumnName, ['number'], 'ONLY', context.adaptableApi);
             const groupByParameter = extractParameter('ONLY', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -477,7 +479,7 @@ export const aggregatedScalarExpressionFunctions = {
                 getRowNodes: context.getRowNodes,
                 columnType,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'ONLY',
                 type: 'aggregationScalar',
@@ -500,7 +502,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const columnParameter = extractColumnParameter('STD_DEVIATION', args);
             const columnName = columnParameter.value;
-            const columnType = validateColumnType(columnName, ['Number'], 'STD_DEVIATION', context.adaptableApi);
+            const columnType = validateColumnType(columnName, ['number'], 'STD_DEVIATION', context.adaptableApi);
             const groupByParameter = extractParameter('STD_DEVIATION', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -536,7 +538,7 @@ export const aggregatedScalarExpressionFunctions = {
                 getRowNodes: context.getRowNodes,
                 columnType,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'STD_DEVIATION',
                 type: 'aggregationScalar',
@@ -544,14 +546,14 @@ export const aggregatedScalarExpressionFunctions = {
             };
             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.',
+        description: 'Aggregates a column over multiple rows by computing its standard deviation.\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)))',
+            'STD_DEVIATION( [colName] )',
+            'STD_DEVIATION( COL(name: string))',
+            'STD_DEVIATION( [colNameA], GROUP_BY( [colNameB] ))',
+            'STD_DEVIATION( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
         ],
-        examples: ['ONLY([colA])', 'ONLY([colA], GROUP_BY([colB]))'],
+        examples: ['STD_DEVIATION([colA])', 'STD_DEVIATION([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
         inputs: ['number'],
     },
@@ -559,7 +561,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const minColumnParameter = extractColumnParameter('MIN', args);
             const minColumnName = minColumnParameter.value;
-            const columnType = validateColumnType(minColumnName, ['Number', 'Date'], 'MIN', context.adaptableApi);
+            const columnType = validateColumnType(minColumnName, ['number', 'date'], 'MIN', context.adaptableApi);
             const groupByParameter = extractParameter('MIN', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -577,7 +579,7 @@ export const aggregatedScalarExpressionFunctions = {
                                 if (minValue === Number.MAX_VALUE) {
                                     return rowValue;
                                 }
-                                if (columnType === 'Number') {
+                                if (columnType === 'number') {
                                     const numericRowValue = getNumericValue(rowValue);
                                     return numericRowValue < minValue ? numericRowValue : minValue;
                                 }
@@ -600,7 +602,7 @@ export const aggregatedScalarExpressionFunctions = {
                 getRowNodes: context.getRowNodes,
                 columnType,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'MIN',
                 type: 'aggregationScalar',
@@ -623,7 +625,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const maxColumnParameter = extractColumnParameter('MAX', args);
             const maxColumnName = maxColumnParameter.value;
-            const columnType = validateColumnType(maxColumnName, ['Number', 'Date'], 'MAX', context.adaptableApi);
+            const columnType = validateColumnType(maxColumnName, ['number', 'date'], 'MAX', context.adaptableApi);
             const groupByParameter = extractParameter('MAX', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -641,7 +643,7 @@ export const aggregatedScalarExpressionFunctions = {
                                 if (maxValue === Number.MIN_VALUE) {
                                     return rowValue;
                                 }
-                                if (columnType === 'Number') {
+                                if (columnType === 'number') {
                                     const numericRowValue = getNumericValue(rowValue);
                                     return numericRowValue > maxValue ? numericRowValue : maxValue;
                                 }
@@ -664,7 +666,7 @@ export const aggregatedScalarExpressionFunctions = {
                 getRowNodes: context.getRowNodes,
                 columnType,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'MAX',
                 type: 'aggregationScalar',
@@ -685,10 +687,9 @@ export const aggregatedScalarExpressionFunctions = {
     },
     QUANT: {
         handler(args, context) {
-            var _a, _b, _c;
             const quantileColumnParameter = extractColumnParameter('QUANT', args);
             const quantileColumnName = quantileColumnParameter.value;
-            const columnType = validateColumnType(quantileColumnName, ['Number'], 'QUANT', context.adaptableApi);
+            const columnType = validateColumnType(quantileColumnName, ['number'], 'QUANT', context.adaptableApi);
             const qNumberCandidates = args.filter((arg) => typeof arg === 'number');
             if (qNumberCandidates.length !== 1) {
                 throw new ExpressionEvaluationError('QUANT', 'expects a single positive numeric argument as q-quantile');
@@ -697,9 +698,9 @@ export const aggregatedScalarExpressionFunctions = {
             const groupByOperand = extractParameter('QUANT', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
-            const groupByColumnNames = groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value;
+            const groupByColumnNames = groupByOperand?.value;
             let quantReducer;
-            if (groupByColumnNames === null || groupByColumnNames === void 0 ? void 0 : groupByColumnNames.length) {
+            if (groupByColumnNames?.length) {
                 // do the heavy-lifting in done()
                 quantReducer = {
                     initialValue: {},
@@ -711,11 +712,10 @@ export const aggregatedScalarExpressionFunctions = {
                         return nodeValueMap;
                     },
                     done: (nodeValueMap, groupItems) => {
-                        var _a, _b;
-                        const populationSize = (_b = (_a = groupItems === null || groupItems === void 0 ? void 0 : groupItems.filter((rowNode) => {
+                        const populationSize = groupItems?.filter((rowNode) => {
                             const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
                             return isDefinedValue(rowValue);
-                        })) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+                        })?.length ?? 0;
                         const bucketsMap = new Map();
                         for (let step = 1; step <= qNumber; step++) {
                             bucketsMap.set(step, populationSize * (step / qNumber));
@@ -745,10 +745,10 @@ export const aggregatedScalarExpressionFunctions = {
             }
             else {
                 // in case of non-grouped quantiles, we are able to calculate the buckets beforehand (which is the most efficient)
-                const populationSize = (_c = (_b = (_a = context.adaptableApi.gridApi.getAllRowNodes()) === null || _a === void 0 ? void 0 : _a.filter((rowNode) => {
+                const populationSize = context.adaptableApi.gridApi.getAllRowNodes()?.filter((rowNode) => {
                     const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
                     return isDefinedValue(rowValue);
-                })) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+                })?.length ?? 0;
                 const bucketsMap = new Map();
                 for (let step = 1; step <= qNumber; step++) {
                     bucketsMap.set(step, populationSize * (step / qNumber));
@@ -785,7 +785,11 @@ export const aggregatedScalarExpressionFunctions = {
                 getRowNodes: context.getRowNodes,
                 aggregationParams: {
                     reducers: {
-                        QUANT: Object.assign({ name: 'QUANT', field: quantileColumnName }, quantReducer),
+                        QUANT: {
+                            name: 'QUANT',
+                            field: quantileColumnName,
+                            ...quantReducer,
+                        },
                     },
                 },
                 rowValueGetter: (rowNode, rowBucketMap) => {
@@ -797,7 +801,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 columnType,
             };
-            addGroupByParams(groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByOperand?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'QUANT',
                 type: 'aggregationScalar',
@@ -864,7 +868,7 @@ export const aggregatedScalarExpressionFunctions = {
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
             };
-            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'COUNT',
                 type: 'aggregationScalar',
@@ -886,7 +890,7 @@ export const aggregatedScalarExpressionFunctions = {
     OVER: {
         handler(args, context) {
             const columnParameter = extractColumnParameter('OVER', args);
-            validateColumnType(columnParameter.value, ['Number', 'Date'], 'OVER', context.adaptableApi);
+            validateColumnType(columnParameter.value, ['number', 'date'], 'OVER', context.adaptableApi);
             const result = {
                 type: 'operand',
                 name: 'OVER',
@@ -902,7 +906,7 @@ export const aggregatedScalarExpressionFunctions = {
     WEIGHT: {
         handler(args, context) {
             const columnParameter = extractColumnParameter('WEIGHT', args);
-            validateColumnType(columnParameter.value, ['Number'], 'WEIGHT', context.adaptableApi);
+            validateColumnType(columnParameter.value, ['number'], 'WEIGHT', context.adaptableApi);
             const result = {
                 type: 'operand',
                 name: 'WEIGHT',
@@ -943,6 +947,268 @@ export const aggregatedScalarExpressionFunctions = {
         examples: ['[col1]', 'COL("col1")'],
         category: 'special',
     },
+    PREVIOUS: {
+        handler(args, context) {
+            const prevColumnParameter = extractColumnParameter('PREVIOUS', args);
+            const prevColumnName = prevColumnParameter.value;
+            const groupByParameter = extractParameter('PREVIOUS', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const overParameter = extractParameter('PREVIOUS', 'operand', ['OVER'], args);
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        PREVIOUS: {
+                            name: 'PREVIOUS',
+                            field: prevColumnName,
+                            initialValue: {
+                                map: {},
+                                previousValue: undefined,
+                            },
+                            reducer: (indexMapAndPrevious, rowValue, rowNode) => {
+                                if (isDefinedValue(indexMapAndPrevious.previousValue)) {
+                                    indexMapAndPrevious.map[rowNode.id] = indexMapAndPrevious.previousValue;
+                                }
+                                indexMapAndPrevious.previousValue = rowValue;
+                                return indexMapAndPrevious;
+                            },
+                            done: (indexMapAndPrevious) => {
+                                return indexMapAndPrevious.map;
+                            },
+                        },
+                    },
+                },
+                rowValueGetter: (rowNode, indexMap) => {
+                    return indexMap[rowNode.id];
+                },
+                rowFilterFn: context.filterFn,
+                sortByColumn: overParameter.value,
+            };
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'PREVIOUS',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Returns the value of the previous element in the given column, when ordered by the second given column.\nOptionally the value may be computed within provided individual groups',
+        signatures: [
+            'PREVIOUS( [colNameA], OVER [colNameB] )',
+            'PREVIOUS( COL(nameA: string), OVER( COL(nameB: string)))',
+            'PREVIOUS( [colNameA], OVER( [colNameB] ), GROUP_BY( [colNameC] ))',
+            'PREVIOUS( COL(nameA: string), OVER( COL(nameB: string)), GROUP_BY( COL(nameC: string)))',
+        ],
+        examples: ['PREVIOUS([colA], OVER[colB])', 'PREVIOUS([colA], OVER([colB]), GROUP_BY([colC]))'],
+        category: 'refs',
+    },
+    NEXT: {
+        handler(args, context) {
+            const nextColumnParameter = extractColumnParameter('NEXT', args);
+            const nextColumnName = nextColumnParameter.value;
+            const groupByParameter = extractParameter('NEXT', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const overParameter = extractParameter('NEXT', 'operand', ['OVER'], args);
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        NEXT: {
+                            name: 'NEXT',
+                            field: nextColumnName,
+                            initialValue: {
+                                map: {},
+                                previousRowNode: undefined,
+                            },
+                            reducer: (indexMapAndPreviousRowNode, rowValue, rowNode) => {
+                                if (isDefinedValue(rowValue) &&
+                                    isDefinedValue(indexMapAndPreviousRowNode.previousRowNode)) {
+                                    indexMapAndPreviousRowNode.map[indexMapAndPreviousRowNode.previousRowNode.id] =
+                                        rowValue;
+                                }
+                                indexMapAndPreviousRowNode.previousRowNode = rowNode;
+                                return indexMapAndPreviousRowNode;
+                            },
+                            done: (indexMapAndPreviousRowNode) => {
+                                return indexMapAndPreviousRowNode.map;
+                            },
+                        },
+                    },
+                },
+                rowValueGetter: (rowNode, indexMap) => {
+                    return indexMap[rowNode.id];
+                },
+                rowFilterFn: context.filterFn,
+                sortByColumn: overParameter.value,
+            };
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'NEXT',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Returns the value of the next element in the given column, when ordered by the second given column.\nOptionally the value may be computed within provided individual groups',
+        signatures: [
+            'NEXT( [colNameA], OVER [colNameB] )',
+            'NEXT( COL(nameA: string), OVER( COL(nameB: string)))',
+            'NEXT( [colNameA], OVER( [colNameB] ), GROUP_BY( [colNameC] ))',
+            'NEXT( COL(nameA: string), OVER( COL(nameB: string)), GROUP_BY( COL(nameC: string)))',
+        ],
+        examples: ['NEXT([colA], OVER[colB])', 'NEXT([colA], OVER([colB]), GROUP_BY([colC]))'],
+        category: 'refs',
+    },
+    FIRST: {
+        handler(args, context) {
+            const firstColumnParameter = extractColumnParameter('FIRST', args);
+            const firstColumnName = firstColumnParameter.value;
+            const groupByParameter = extractParameter('FIRST', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const overParameter = extractParameter('FIRST', 'operand', ['OVER'], args);
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        FIRST: {
+                            name: 'FIRST',
+                            field: firstColumnName,
+                            initialValue: undefined,
+                            reducer: (firstElement, rowValue) => {
+                                if (isDefinedValue(firstElement)) {
+                                    return firstElement;
+                                }
+                                return rowValue;
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                sortByColumn: overParameter.value,
+            };
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'FIRST',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Returns the first value in the given column, when ordered by the second given column.\nOptionally the value may be computed within provided individual groups',
+        signatures: [
+            'FIRST( [colNameA], OVER [colNameB] )',
+            'FIRST( COL(nameA: string), OVER( COL(nameB: string)))',
+            'FIRST( [colNameA], OVER( [colNameB] ), GROUP_BY( [colNameC] ))',
+            'FIRST( COL(nameA: string), OVER( COL(nameB: string)), GROUP_BY( COL(nameC: string)))',
+        ],
+        examples: ['FIRST([colA], OVER[colB])', 'FIRST([colA], OVER([colB]), GROUP_BY([colC]))'],
+        category: 'refs',
+    },
+    LAST: {
+        handler(args, context) {
+            const lastColumnParameter = extractColumnParameter('LAST', args);
+            const lastColumnName = lastColumnParameter.value;
+            const groupByParameter = extractParameter('LAST', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const overParameter = extractParameter('LAST', 'operand', ['OVER'], args);
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        LAST: {
+                            name: 'LAST',
+                            field: lastColumnName,
+                            initialValue: undefined,
+                            reducer: (lastElement, rowValue) => {
+                                if (isDefinedValue(rowValue)) {
+                                    return rowValue;
+                                }
+                                return lastElement;
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                sortByColumn: overParameter.value,
+            };
+            addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'LAST',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Returns the last value in the given column, when ordered by the second given column.\nOptionally the value may be computed within provided individual groups',
+        signatures: [
+            'LAST( [colNameA], OVER [colNameB] )',
+            'LAST( COL(nameA: string), OVER( COL(nameB: string)))',
+            'LAST( [colNameA], OVER( [colNameB] ), GROUP_BY( [colNameC] ))',
+            'LAST( COL(nameA: string), OVER( COL(nameB: string)), GROUP_BY( COL(nameC: string)))',
+        ],
+        examples: ['LAST([colA], OVER[colB])', 'LAST([colA], OVER([colB]), GROUP_BY([colC]))'],
+        category: 'refs',
+    },
+    ABSOLUTE_DIFF: {
+        handler(args, context) {
+            const absoluteDiffColumnParameter = extractColumnParameter('ABSOLUTE_DIFF', args);
+            const absoluteDiffColumnName = absoluteDiffColumnParameter.value;
+            const columnType = validateColumnType(absoluteDiffColumnName, ['number'], 'ABSOLUTE_DIFF', context.adaptableApi);
+            const relativeValueParameter = extractParameter('ABSOLUTE_DIFF', 'aggregationScalar', ['AVG', 'MEDIAN', 'MODE', 'MIN', 'MAX', 'PREVIOUS', 'NEXT', 'FIRST', 'LAST'], args);
+            const groupByParameter = extractParameter('ABSOLUTE_DIFF', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            if (!!groupByParameter) {
+                // ensure the GROUP_BY is NOT on the ABSOLUTE_DIFF function
+                // it should be on the AGGREGATION function
+                throw new ExpressionEvaluationError('GROUP_BY', `should be passed as an argument to the '${relativeValueParameter.name}' aggregation function!`);
+            }
+            const absoluteDiffExpressionEvaluation = mapWrappedAggregationToDiff(context, 'ABSOLUTE_DIFF', relativeValueParameter, absoluteDiffColumnName, columnType);
+            const result = {
+                name: 'ABSOLUTE_DIFF',
+                type: 'aggregationScalar',
+                value: absoluteDiffExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the absolute difference between the column values and the provided relative value.\nOptionally the aggregation may be computed within provided individual groups.',
+        signatures: ['ABSOLUTE_DIFF( [colName], aggregationOp: AVG|MIN|MAX|MEDIAN|MODE )'],
+        examples: [
+            'ABSOLUTE_DIFF([price], MAX([price]))',
+            'ABSOLUTE_DIFF([price], AVG([price], GROUP_BY([currency])))',
+        ],
+        category: 'aggregation',
+    },
+    PERCENT_DIFF: {
+        handler(args, context) {
+            const percentDiffColumnParameter = extractColumnParameter('PERCENT_DIFF', args);
+            const percentDiffColumnName = percentDiffColumnParameter.value;
+            const columnType = validateColumnType(percentDiffColumnName, ['number'], 'PERCENT_DIFF', context.adaptableApi);
+            const relativeValueParameter = extractParameter('PERCENT_DIFF', 'aggregationScalar', ['AVG', 'MEDIAN', 'MODE', 'MIN', 'MAX', 'PREVIOUS', 'NEXT', 'FIRST', 'LAST'], args);
+            const groupByParameter = extractParameter('PERCENT_DIFF', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            if (!!groupByParameter) {
+                // ensure the GROUP_BY is NOT on the ABSOLUTE_DIFF function
+                // it should be on the AGGREGATION function
+                throw new ExpressionEvaluationError('GROUP_BY', `should be passed as an argument to the '${relativeValueParameter.name}' aggregation function!`);
+            }
+            const percentDiffExpressionEvaluation = mapWrappedAggregationToDiff(context, 'PERCENT_DIFF', relativeValueParameter, percentDiffColumnName, columnType);
+            const result = {
+                name: 'PERCENT_DIFF',
+                type: 'aggregationScalar',
+                value: percentDiffExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the percentage difference between the column values and the provided relative value.\nOptionally the aggregation may be computed within provided individual groups.',
+        signatures: ['PERCENT_DIFF( [colName], aggregationOp: AVG|MIN|MAX|MEDIAN|MODE )'],
+        examples: [
+            'PERCENT_DIFF([price], MAX([price]))',
+            'PERCENT_DIFF([price], AVG([price], GROUP_BY([currency])))',
+        ],
+        category: 'aggregation',
+    },
 };
 const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, context) => {
     const aggregationEvaluation = aggregationParameter.value;
@@ -973,7 +1239,7 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
                 },
                 reducer: (cumulationBag, rowValue, rowNode) => {
                     if (isDefinedValue(rowValue)) {
-                        if (aggregationEvaluation.columnType === 'Date') {
+                        if (aggregationEvaluation.columnType === 'date') {
                             if (cumulationBag.currentValue === aggregationReducer.initialValue ||
                                 isAfter(parseDateValue(cumulationBag.currentValue), parseDateValue(rowValue))) {
                                 cumulationBag.currentValue = rowValue;
@@ -999,7 +1265,7 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
                     },
                     reducer: (cumulationBag, rowValue, rowNode) => {
                         if (isDefinedValue(rowValue)) {
-                            if (aggregationEvaluation.columnType === 'Date') {
+                            if (aggregationEvaluation.columnType === 'date') {
                                 if (cumulationBag.currentValue === aggregationReducer.initialValue ||
                                     isAfter(parseDateValue(rowValue), parseDateValue(cumulationBag.currentValue))) {
                                     cumulationBag.currentValue = rowValue;
@@ -1025,11 +1291,10 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
                             numberOfCumulatedValues: 0,
                         },
                         reducer: (cumulationBag, rowValue, rowNode) => {
-                            var _a, _b;
                             if (isDefinedValue(rowValue)) {
-                                if ((_a = aggregationEvaluation.context) === null || _a === void 0 ? void 0 : _a.weightParam) {
+                                if (aggregationEvaluation.context?.weightParam) {
                                     // weighted average
-                                    const weightValue = (_b = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, aggregationEvaluation.context.weightParam.value)) !== null && _b !== void 0 ? _b : 0;
+                                    const weightValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, aggregationEvaluation.context.weightParam.value) ?? 0;
                                     cumulationBag.currentValue =
                                         cumulationBag.currentValue + rowValue * weightValue;
                                     cumulationBag.numberOfCumulatedValues =
@@ -1108,10 +1373,39 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
     };
     return cumulationExpressionEvaluation;
 };
+const mapWrappedAggregationToDiff = (context, diffWrapperFunction, aggregationParameter, columnName, columnType) => {
+    const aggregationEvaluation = aggregationParameter.value;
+    const absoluteDiffExpressionEvaluation = {
+        aggregationParams: aggregationEvaluation.aggregationParams,
+        rowValueGetter: (rowNode, wrappedAggregatedValue) => {
+            const aggregatedValue = typeof aggregationEvaluation.rowValueGetter === 'function'
+                ? aggregationEvaluation.rowValueGetter(rowNode, wrappedAggregatedValue)
+                : wrappedAggregatedValue;
+            const cellValue = getNumericValue(context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, columnName));
+            if (cellValue == null || aggregatedValue == null) {
+                return null;
+            }
+            if (diffWrapperFunction === 'ABSOLUTE_DIFF') {
+                return cellValue - aggregatedValue;
+            }
+            if (diffWrapperFunction === 'PERCENT_DIFF') {
+                return ((cellValue - aggregatedValue) / aggregatedValue) * 100;
+            }
+            // should never happen
+            return null;
+        },
+        rowFilterFn: aggregationEvaluation.rowFilterFn,
+        getRowNodes: context.getRowNodes,
+        sortByColumn: aggregationEvaluation.sortByColumn,
+        context: aggregationEvaluation.context,
+        columnType,
+    };
+    return absoluteDiffExpressionEvaluation;
+};
 export const aggregatedScalarExpressionFunctionNames = getTypedKeys(aggregatedScalarExpressionFunctions);
 // !! mutates expressionEvaluation
 export const addGroupByParams = (groupByColumnNames, expressionEvaluation) => {
-    if (groupByColumnNames === null || groupByColumnNames === void 0 ? void 0 : groupByColumnNames.length) {
+    if (groupByColumnNames?.length) {
         expressionEvaluation.aggregationParams.groupBy = groupByColumnNames.map((columnName) => ({
             field: columnName,
         }));