@adaptabletools/adaptable 11.0.0-canary.3 → 11.0.0-canary.7

package/src/Utilities/Constants/DocumentationLinkConstants.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LicenseDocsLink = exports.PrimaryKeyDocsLink = exports.PredicateDocsLink = exports.AggregationQueryDocsLink = exports.ObservableQueryDocsLink = exports.ScalarQueryDocsLink = exports.BooleanQueryDocsLink = exports.ExpressionEditorDocsLink = exports.HOST_URL_DOCS = void 0;
+exports.LicenseDocsLink = exports.PrimaryKeyDocsLink = exports.PredicateDocsLink = exports.AggregatedScalarQueryDocsLink = exports.AggregatedBooleanQueryDocsLink = exports.ObservableQueryDocsLink = exports.ScalarQueryDocsLink = exports.BooleanQueryDocsLink = exports.ExpressionEditorDocsLink = exports.HOST_URL_DOCS = void 0;
 exports.HOST_URL_DOCS = 'https://docs.adaptabletools.com/docs';
 exports.ExpressionEditorDocsLink = `${exports.HOST_URL_DOCS}/adaptableql/expression-editor`;
 exports.BooleanQueryDocsLink = `${exports.HOST_URL_DOCS}/adaptableql/expression/#boolean-expressions`;
 exports.ScalarQueryDocsLink = `${exports.HOST_URL_DOCS}/adaptableql/expression/#scalar-expressions`;
 exports.ObservableQueryDocsLink = `${exports.HOST_URL_DOCS}/adaptableql/expression/#observable-expressions`;
-exports.AggregationQueryDocsLink = `${exports.HOST_URL_DOCS}/adaptableql/expression/#aggregation-expressions`;
+exports.AggregatedBooleanQueryDocsLink = `${exports.HOST_URL_DOCS}/adaptableql/expression/#aggregation-expressions`;
+exports.AggregatedScalarQueryDocsLink = `${exports.HOST_URL_DOCS}/adaptableql/expression/#aggregation-expressions`;
 exports.PredicateDocsLink = `${exports.HOST_URL_DOCS}/adaptableql/predicate`;
 exports.PrimaryKeyDocsLink = `${exports.HOST_URL_DOCS}/key-topics/primary-key`;
 exports.LicenseDocsLink = `${exports.HOST_URL_DOCS}/getting-started/licence`;

package/src/Utilities/Defaults/DefaultAdaptableOptions.js

@@ -8,9 +8,10 @@ const UIHelper_1 = tslib_1.__importStar(require("../../View/UIHelper"));
 const booleanExpressionFunctions_1 = require("../ExpressionFunctions/booleanExpressionFunctions");
 const scalarExpressionFunctions_1 = require("../ExpressionFunctions/scalarExpressionFunctions");
 const observableExpressionFunctions_1 = require("../ExpressionFunctions/observableExpressionFunctions");
-const aggregationExpressionFunctions_1 = require("../ExpressionFunctions/aggregationExpressionFunctions");
+const aggregatedBooleanExpressionFunctions_1 = require("../ExpressionFunctions/aggregatedBooleanExpressionFunctions");
 const AdaptablePredicate_1 = require("../../PredefinedConfig/Common/AdaptablePredicate");
 const Enums_1 = require("../../PredefinedConfig/Common/Enums");
+const aggregatedScalarExpressionFunctions_1 = require("../ExpressionFunctions/aggregatedScalarExpressionFunctions");
 exports.DefaultAdaptableOptions = {
     adaptableId: GeneralConstants.ADAPTABLE_ID,
     adaptableStateKey: undefined,
@@ -19,20 +20,22 @@ exports.DefaultAdaptableOptions = {
     autogeneratePrimaryKey: false,
     userName: GeneralConstants.USER_NAME,
     predefinedConfig: undefined,
-    notificationsOptions: {
+    alertOptions: {
         alertForms: undefined,
         maxAlertsInStore: 20,
+        cellHighlightDuration: 3000,
+        dataChangeDetectionPolicy: 'rawValue',
+        actionHandlers: undefined,
+    },
+    notificationsOptions: {
         maxNotifications: 3,
         position: 'BottomRight',
         duration: 3000,
-        cellHighlightDuration: 3000,
-        dataChangeDetectionPolicy: 'rawValue',
         showProgressBar: false,
         closeWhenClicked: false,
         pauseWhenHovering: false,
         isDraggable: false,
         transition: 'Slide',
-        actionHandlers: undefined,
         showApplicationIcon: false,
         showSystemStatusMessageNotifications: false,
         maxSystemMessagesInStore: 100,
@@ -50,6 +53,21 @@ exports.DefaultAdaptableOptions = {
             BackColor: UIHelper_1.getHexForName(UIHelper_1.GRAY),
         },
     },
+    adaptableQLOptions: {
+        caseSensitiveTextComparisons: false,
+        externallyEvaluatedModules: [],
+        expressionOptions: {
+            defaultBooleanFunctions: booleanExpressionFunctions_1.booleanExpressionFunctions,
+            defaultScalarFunctions: scalarExpressionFunctions_1.scalarExpressionFunctions,
+            defaultObservableFunctions: observableExpressionFunctions_1.observableExpressionFunctions,
+            defaultAggregatedBooleanFunctions: aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions,
+            defaultAggregatedScalarFunctions: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions,
+            moduleExpressionFunctions: undefined,
+            queryableColumns: undefined,
+            performExpressionValidation: true,
+            maxTimeframeSize: 28800000,
+        },
+    },
     containerOptions: {
         adaptableContainer: 'adaptable',
         agGridContainer: 'grid',
@@ -105,7 +123,6 @@ exports.DefaultAdaptableOptions = {
         currentCalendar: 'United Kingdom',
         cellSummaryOperations: undefined,
         customSortComparers: undefined,
-        caseSensitiveTextComparisons: false,
     },
     layoutOptions: {
         includeExpandedRowGroups: false,
@@ -153,7 +170,6 @@ exports.DefaultAdaptableOptions = {
     },
     searchOptions: {
         excludeColumnFromQuickSearch: undefined,
-        serverSearchOptions: undefined,
         clearSearchesOnStartUp: false,
         quickSearchPlaceholder: 'Search',
         filterResultsAfterQuickSearch: false,
@@ -206,16 +222,6 @@ exports.DefaultAdaptableOptions = {
         maxWidth: undefined,
         toolPanelOrder: ['filters', 'columns', 'adaptable'],
     },
-    queryLanguageOptions: {
-        defaultBooleanFunctions: booleanExpressionFunctions_1.booleanExpressionFunctions,
-        defaultScalarFunctions: scalarExpressionFunctions_1.scalarExpressionFunctions,
-        defaultObservableFunctions: observableExpressionFunctions_1.observableExpressionFunctions,
-        defaultAggregationFunctions: aggregationExpressionFunctions_1.aggregationExpressionFunctions,
-        moduleExpressionFunctions: undefined,
-        queryableColumns: undefined,
-        performExpressionValidation: true,
-        maxTimeframeSize: 28800000,
-    },
     dataChangeHistoryOptions: {
         activeByDefault: false,
         showDataChange: undefined,

package/src/Utilities/ExpressionFunctions/{aggregationExpressionFunctions.d.ts → aggregatedBooleanExpressionFunctions.d.ts}

@@ -2,5 +2,5 @@ import { ExpressionFunction } from '../../parser/src/types';
 declare type AggregationFunctionName = 'WHERE' | 'COL' | AggregationFunction | ComparisonFunction;
 declare type AggregationFunction = 'SUM';
 declare type ComparisonFunction = 'EQ' | 'NEQ' | 'LT' | 'GT' | 'LTE' | 'GTE';
-export declare const aggregationExpressionFunctions: Record<AggregationFunctionName, ExpressionFunction>;
+export declare const aggregatedBooleanExpressionFunctions: Record<AggregationFunctionName, ExpressionFunction>;
 export {};

package/src/Utilities/ExpressionFunctions/{aggregationExpressionFunctions.js → aggregatedBooleanExpressionFunctions.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregationExpressionFunctions = void 0;
+exports.aggregatedBooleanExpressionFunctions = void 0;
 const tslib_1 = require("tslib");
 const rxjs_1 = require("rxjs");
 const parseInt_1 = tslib_1.__importDefault(require("lodash/parseInt"));
@@ -14,7 +14,7 @@ const aggregationScalarOperandMap = {
 // 1. block containing a numeric value (any digits) (required)
 // 2. block containing a single 'K', 'M' or 'B' letter (optional) (case insensitive)
 const CRITERIA_REGEX = /^(?:\s*)(\d+)(K|M|B)?$/i;
-exports.aggregationExpressionFunctions = {
+exports.aggregatedBooleanExpressionFunctions = {
     WHERE: {
         handler(args, context) {
             return expressionFunctionUtils_1.handleWhereFunction(args, context);
@@ -46,7 +46,7 @@ exports.aggregationExpressionFunctions = {
         handler(args, context) {
             return expressionFunctionUtils_1.handleColumnFunction(args, context);
         },
-        description: 'References a grid column by name',
+        description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
         examples: ['[col1]', "COL('col1')"],
     },
@@ -55,7 +55,7 @@ exports.aggregationExpressionFunctions = {
             return handleAggregationCondition(args, context, '=', (aggregatedValue, conditionValue) => aggregatedValue === conditionValue);
         },
         isHiddenFromMenu: true,
-        description: 'Evaluates if the aggregation result is equals a numerical value defined either as a number or a string abbreviation for thousands(K), millions(M) or billions(B)',
+        description: 'Evaluates if the aggregation result equals a numerical value defined either as a number or a string abbreviation for thousands(K), millions(M) or billions(B)',
         signatures: [
             'SUM() = number',
             `SUM() = '%number%(K|M|B)'`,

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

@@ -0,0 +1,24 @@
+import { ExpressionFunction } from '../../parser/src/types';
+import { BaseParameter } from './expressionFunctionUtils';
+import { RowNode } from '@ag-grid-community/all-modules';
+import { AggregateParams } from './scalarAggregationHelper';
+export declare type AggregatedScalarFunctionName = AggregationFunction | OperandFunction;
+declare type AggregationFunction = 'SUM' | 'PERCENTAGE' | 'AVG' | 'MIN' | 'MAX' | 'CUMUL';
+declare type OperandFunction = 'COL' | 'OVER' | 'GROUP_BY';
+export interface AggregationParameter extends BaseParameter<'aggregation', AggregationFunction> {
+    value: AggregatedScalarExpressionEvaluation;
+}
+export interface OverParameter extends BaseParameter<'operand', 'OVER'> {
+    value: string;
+}
+export interface GroupByParameter extends BaseParameter<'operand', 'GROUP_BY'> {
+    value: string;
+}
+export interface AggregatedScalarExpressionEvaluation {
+    aggregationParams: AggregateParams<any, string | number>;
+    rowValueGetter?: (rowNode: RowNode, aggregationValue: number) => string | number | Date | boolean;
+    columnDependencies: string[];
+    cumulateOver?: string;
+}
+export declare const aggregatedScalarExpressionFunctions: Record<AggregatedScalarFunctionName, ExpressionFunction>;
+export {};

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

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

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

@@ -0,0 +1 @@
+export declare const normalizeDateParams: (args: [string | number | Date, string | number | Date]) => [number | Date, number | Date];

package/src/Utilities/ExpressionFunctions/dateUtils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDateParams = void 0;
+exports.normalizeDateParams = (args) => {
+    let [first, second] = args;
+    if (typeof first === 'string') {
+        first = new Date(first);
+    }
+    if (typeof second === 'string') {
+        second = new Date(second);
+    }
+    return [first, second];
+};

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

@@ -0,0 +1,35 @@
+declare type VoidFn = () => void;
+declare type Pair<KeyType, ValueType> = {
+    value?: ValueType;
+    map?: Map<KeyType, Pair<KeyType, ValueType>>;
+    revision?: number;
+};
+export declare type DeepMapVisitFn<KeyType, ValueType> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn) => void;
+export declare class DeepMap<KeyType, ValueType> {
+    private map;
+    private length;
+    private revision;
+    static clone<KeyType, ValueType>(map: DeepMap<KeyType, ValueType>): DeepMap<KeyType, ValueType>;
+    constructor(initial?: [KeyType[], ValueType][]);
+    set(keys: KeyType[] & {
+        length: Omit<number, 0>;
+    }, value: ValueType): this;
+    get(keys: KeyType[]): ValueType | undefined;
+    get size(): number;
+    clear(): void;
+    delete(keys: KeyType[]): boolean;
+    has(keys: KeyType[]): boolean;
+    private visitKey;
+    visit: (fn: DeepMapVisitFn<KeyType, ValueType>) => void;
+    visitDepthFirst: (fn: (value: ValueType, keys: KeyType[], indexInGroup: number, next?: VoidFn) => void) => void;
+    private visitWithNext;
+    private getArray;
+    values(): Generator<ValueType, void, unknown>;
+    keys(): Generator<KeyType[], void, unknown>;
+    entries(): Generator<[KeyType[], ValueType], void, unknown>;
+    topDownEntries(): [KeyType[], ValueType][];
+    topDownKeys(): KeyType[][];
+    topDownValues(): ValueType[];
+    private sortedIterator;
+}
+export {};