@adaptabletools/adaptable 11.0.0-canary.5 → 11.0.0-canary.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "11.0.0-canary.5",
+  "version": "11.0.0-canary.6",
   "description": "Powerful data-agnostic HTML5 datagrid add-on that sits on top of an underlying grid component and provides all the rich functionality that advanced users expect from their DataGrids and Data Tables",
   "keywords": [
     "web-components",

package/publishTimestamp.d.ts

@@ -1,2 +1,2 @@
-declare const _default: 1645013151802;
+declare const _default: 1645166555862;
 export default _default;

package/publishTimestamp.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = 1645013151802;
+exports.default = 1645166555862;

package/src/AdaptableOptions/AdaptableOptions.d.ts

@@ -72,7 +72,7 @@ export interface AdaptableOptions {
      */
     userName?: string;
     /**
-     * The AG Grid object which AdapTable interacts with.  Note: if using React or Angular Wrapper, no need to populate this property as AdapTable wires it up differently
+     * The AG Grid object which AdapTable interacts with.  Note: if using AdapTable React or AdapTable Angular, no need to populate this property as AdapTable wires it up differently
      *
      * @defaultValue n/a (Mandatory)
      */

package/src/AdaptableOptions/ContainerOptions.d.ts

@@ -17,7 +17,7 @@ export interface ContainerOptions {
      */
     agGridContainer?: string | HTMLElement;
     /**
-     *  how long AdapTable waits for AG Grid before giving up connecting to it; useful when AG Grid is instantiated separately (eg: by React or Angular Wrappers)
+     *  how long AdapTable waits for AG Grid before giving up connecting to it; useful when AG Grid is instantiated separately (eg: by AdapTable React or AdapTable Angular)
      *
      * @defaultValue 60s
      * @gridInfoItem

package/src/AdaptableOptions/QueryLanguageOptions.d.ts

@@ -26,12 +26,12 @@ export interface QueryLanguageOptions {
      */
     defaultObservableFunctions?: ExpressionFunctionMap;
     /**
-     * Aggregation Expression Functions available in AdapTableQL
+     * Aggregated Boolean Expression Functions available in AdapTableQL
      *
      * @defaultValue null (sets all)
      * @gridInfoItem
      */
-    defaultAggregationFunctions?: ExpressionFunctionMap;
+    defaultAggregatedBooleanFunctions?: ExpressionFunctionMap;
     /**
      * Module specific ExpressionFunctions; if not defined, it falls back to the defined default values
      *
@@ -70,5 +70,5 @@ export interface ModuleExpressionFunctions {
     booleanFunctions?: ExpressionFunctionMap;
     scalarFunctions?: ExpressionFunctionMap;
     observableFunctions?: ExpressionFunctionMap;
-    aggregationFunctions?: ExpressionFunctionMap;
+    aggregatedBooleanFunctions?: ExpressionFunctionMap;
 }

package/src/AdaptableOptions/UserInterfaceOptions.d.ts

@@ -89,7 +89,7 @@ export interface UserInterfaceOptions {
     /**
      * Which sections to show in the Grid Info Screen
      *
-     * @defaultValue ['GridSummary', 'AdaptableOptions','ColumnInfo']
+     * @defaultValue ['GridSummary', 'AdaptableOptions', 'ColumnInfo']
      */
     gridInfoSections?: GridInfoSections;
 }

package/src/Api/AdaptableApi.d.ts

@@ -35,6 +35,7 @@ import { PredicateApi } from './PredicateApi';
 import { DataChangeHistoryApi } from './DataChangeHistoryApi';
 import { FlashingCellApi } from './FlashingCellApi';
 import { ChartingApi } from './ChartingApi';
+import { SettingsPanelApi } from './SettingsPanelApi';
 /**
  *
  * The `AdaptableApi` provides developers with run-time access to AdapTable.
@@ -147,6 +148,10 @@ export interface AdaptableApi {
      * Provides access to the Schedule Module
      */
     scheduleApi: ScheduleApi;
+    /**
+     * Provides access to the Settings Panel
+     */
+    settingsPanelApi: SettingsPanelApi;
     /**
      * Manages the `Scope` object - used widely to determine where objects are applied
      */

package/src/Api/ColumnApi.d.ts

@@ -35,10 +35,6 @@ export interface ColumnApi {
      * Returns all boolean Columns
      */
     getBooleanColumns(): AdaptableColumn[];
-    /**
-     * Returns all numeric array Columns
-     */
-    getNumericArrayColumns(): AdaptableColumn[];
     /**
      * Returns all Sortable Columns
      */

package/src/Api/Implementation/AdaptableApiImpl.d.ts

@@ -1,5 +1,5 @@
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
-import { AdaptableApi } from '../../types';
+import { AdaptableApi, SettingsPanelApi } from '../../types';
 import { AlertApi } from '../AlertApi';
 import { BulkUpdateApi } from '../BulkUpdateApi';
 import { CalculatedColumnApi } from '../CalculatedColumnApi';
@@ -71,6 +71,7 @@ export declare class AdaptableApiImpl implements AdaptableApi {
     userInterfaceApi: UserInterfaceApi;
     queryApi: QueryApi;
     queryLanguageApi: QueryLanguageApi;
+    settingsPanelApi: SettingsPanelApi;
     toolPanelApi: ToolPanelApi;
     teamSharingApi: TeamSharingApi;
     scopeApi: ScopeApi;

package/src/Api/Implementation/AdaptableApiImpl.js

@@ -38,6 +38,7 @@ const DataChangeHistoryApiImpl_1 = require("./DataChangeHistoryApiImpl");
 const QueryLanguageApiImpl_1 = require("./QueryLanguageApiImpl");
 const FlashingCellApiImpl_1 = require("./FlashingCellApiImpl");
 const ChartingApiImpl_1 = require("./ChartingApiImpl");
+const SettingsPanelApiImpl_1 = require("./SettingsPanelApiImpl");
 class AdaptableApiImpl {
     constructor(adaptable) {
         this.adaptable = adaptable;
@@ -69,6 +70,7 @@ class AdaptableApiImpl {
         this.smartEditApi = new SmartEditApiImpl_1.SmartEditApiImpl(adaptable);
         this.filterApi = new FilterApiImpl_1.FilterApiImpl(adaptable);
         this.systemStatusApi = new SystemStatusApiImpl_1.SystemStatusApiImpl(adaptable);
+        this.settingsPanelApi = new SettingsPanelApiImpl_1.SettingsPanelApiImpl(adaptable);
         this.themeApi = new ThemeApiImpl_1.ThemeApiImpl(adaptable);
         this.userInterfaceApi = new UserInterfaceApiImpl_1.UserInterfaceApiImpl(adaptable);
         this.queryApi = new QueryApiImpl_1.QueryApiImpl(adaptable);

package/src/Api/Implementation/AlertApiImpl.js

@@ -79,10 +79,13 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
             switch (highhlightType) {
                 case 'Error':
                     backgroundColor = 'var(--ab-color-error)';
+                    break;
                 case 'Info':
                     backgroundColor = 'var(--ab-color-info)';
+                    break;
                 case 'Success':
                     backgroundColor = 'var(--ab-color-success)';
+                    break;
                 case 'Warning':
                     backgroundColor = 'var(--ab-color-warn)';
             }
@@ -266,7 +269,7 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
         var _a, _b;
         let ruleDescription = alert.Rule.Predicate
             ? this.adaptable.api.predicateApi.predicateToString(alert.Rule.Predicate)
-            : (_b = (_a = alert.Rule.BooleanExpression) !== null && _a !== void 0 ? _a : alert.Rule.ObservableExpression) !== null && _b !== void 0 ? _b : alert.Rule.AggregationExpression;
+            : (_b = (_a = alert.Rule.BooleanExpression) !== null && _a !== void 0 ? _a : alert.Rule.ObservableExpression) !== null && _b !== void 0 ? _b : alert.Rule.AggregatedBooleanExpression;
         return ruleDescription;
     }
 }

package/src/Api/Implementation/ColumnApiImpl.d.ts

@@ -42,7 +42,6 @@ export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     getColumnFromFriendlyName(columnName: string, logWarning?: boolean): AdaptableColumn;
     getColumnsOfType(dataType: DataType): AdaptableColumn[];
     getNumericColumns(): AdaptableColumn[];
-    getNumericArrayColumns(): AdaptableColumn[];
     getStringColumns(): AdaptableColumn[];
     getDateColumns(): AdaptableColumn[];
     getBooleanColumns(): AdaptableColumn[];

package/src/Api/Implementation/ColumnApiImpl.js

@@ -224,8 +224,6 @@ class ColumnApiImpl extends ApiBase_1.ApiBase {
                 return this.getDateColumns();
             case Enums_1.DataType.Number:
                 return this.getNumericColumns();
-            case Enums_1.DataType.NumberArray:
-                return this.getNumericArrayColumns();
             case Enums_1.DataType.String:
                 return this.getStringColumns();
             default:
@@ -235,9 +233,6 @@ class ColumnApiImpl extends ApiBase_1.ApiBase {
     getNumericColumns() {
         return this.getColumns().filter((c) => c.dataType == Enums_1.DataType.Number);
     }
-    getNumericArrayColumns() {
-        return this.getColumns().filter((c) => c.dataType == Enums_1.DataType.NumberArray);
-    }
     getStringColumns() {
         return this.getColumns().filter((c) => c.dataType == Enums_1.DataType.String);
     }

package/src/Api/Implementation/QueryLanguageApiImpl.d.ts

@@ -5,7 +5,7 @@ import { ExpressionFunctionMap } from '../../types';
 export declare class QueryLanguageApiImpl extends ApiBase implements QueryLanguageApi {
     isValidBooleanExpression(query: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     isValidObservableExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
-    isValidAggregationExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
+    isValidAggregatedBooleanExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     getASTForExpression(query: string): any;
     getColumnsFromExpression(expression: string): string[];
     getQueryableColumnIds(): string[] | undefined;

package/src/Api/Implementation/QueryLanguageApiImpl.js

@@ -25,10 +25,10 @@ class QueryLanguageApiImpl extends ApiBase_1.ApiBase {
         }
         return isValid;
     }
-    isValidAggregationExpression(expression, module, validationErrorMessage) {
+    isValidAggregatedBooleanExpression(expression, module, validationErrorMessage) {
         const { isValid, errorMessage } = this.adaptable.api.internalApi
             .getQueryLanguageService()
-            .validateAggregation(expression, module);
+            .validateAggregatedBoolean(expression, module);
         if (!isValid && validationErrorMessage) {
             LoggingHelper_1.LogAdaptableWarning(`${validationErrorMessage} :: ${errorMessage}`);
         }

package/src/Api/Implementation/SettingsPanelApiImpl.d.ts

@@ -0,0 +1,7 @@
+import { SettingsPanelApi } from '../SettingsPanelApi';
+import { ApiBase } from './ApiBase';
+import { AdaptableModule } from '../../../types';
+export declare class SettingsPanelApiImpl extends ApiBase implements SettingsPanelApi {
+    showSettingsPanel(moduleName?: AdaptableModule): void;
+    showCustomSettingsPanel(name: string): void;
+}

package/src/Api/Implementation/SettingsPanelApiImpl.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsPanelApiImpl = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("./ApiBase");
+const PopupRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/PopupRedux"));
+class SettingsPanelApiImpl extends ApiBase_1.ApiBase {
+    showSettingsPanel(moduleName) {
+        this.dispatchAction(PopupRedux.PopupShowScreen(moduleName));
+    }
+    showCustomSettingsPanel(name) {
+        this.dispatchAction(PopupRedux.PopupShowScreen('CustomSettingsPanelModule', name));
+    }
+}
+exports.SettingsPanelApiImpl = SettingsPanelApiImpl;

package/src/Api/QueryLanguageApi.d.ts

@@ -13,21 +13,21 @@ export interface QueryLanguageApi {
     isValidBooleanExpression(query: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     /**
      * Whether the given ObservableExpression is valid
-     * @param query query to Check
-     * @param module module specific query
-     * @param validationErrorMessage optional validation error message; if provided, the error will be logged
+     * @param expression - ObservableExpression to check
+     * @param module - module specific query
+     * @param validationErrorMessage - optional validation error message; if provided, the error will be logged
      */
     isValidObservableExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     /**
-     * Whether the given AggregationExpression is valid
-     * @param query query to Check
-     * @param module module specific query
-     * @param validationErrorMessage optional validation error message; if provided, the error will be logged
+     * Whether the given AggregatedBooleanExpression is valid
+     * @param expression -  AggregatedBooleanExpression to check
+     * @param module - module specific query
+     * @param validationErrorMessage - optional validation error message; if provided, the error will be logged
      */
-    isValidAggregationExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
+    isValidAggregatedBooleanExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     /**
-     * Returns all Columns referenced in a Query
-     * @param adaptableQuery Query to check
+     * Returns all Columns referenced in a QueryExpression
+     * @param expression - expression to check
      */
     getColumnsFromExpression(expression: string): string[];
     /**

package/src/Api/SettingsPanelApi.d.ts

@@ -0,0 +1,17 @@
+import { AdaptableModule } from '../../types';
+/**
+ * Provides run-time access to the Settings Panel
+ **/
+export interface SettingsPanelApi {
+    /**
+     * Opens settings panel to specified module,
+     * when not specified it opens the first available module
+     * @param moduleName module name
+     */
+    showSettingsPanel(moduleName?: AdaptableModule): void;
+    /**
+     * Opens a the settings panel to the custom module
+     * @param name name of the custom settings panel
+     */
+    showCustomSettingsPanel(name: string): void;
+}

package/src/Api/SettingsPanelApi.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/PredefinedConfig/AlertState.d.ts

@@ -8,7 +8,7 @@ import { AdaptableButton, ButtonContext } from './Common/AdaptableButton';
 import { SuspendableObject } from './Common/SuspendableObject';
 import { AdaptableStyle } from './Common/AdaptableStyle';
 import { XOR } from '../Utilities/Extensions/TypeExtensions';
-import { AdaptableAggregationQuery, AdaptableBooleanQuery, AdaptableObservableQuery } from './Common/AdaptableQuery';
+import { AdaptableAggregatedBooleanQuery, AdaptableBooleanQuery, AdaptableObservableQuery } from './Common/AdaptableQuery';
 import { ButtonStyle } from './Common/ButtonStyle';
 import { AlertButtonContext } from '../types';
 /**
@@ -60,7 +60,7 @@ export interface AlertDefinitionPredicate extends AdaptablePredicate {
  */
 export declare type AlertRule = XOR<{
     Predicate: AlertDefinitionPredicate;
-}, XOR<AdaptableBooleanQuery, XOR<AdaptableObservableQuery, AdaptableAggregationQuery>>>;
+}, XOR<AdaptableBooleanQuery, XOR<AdaptableObservableQuery, AdaptableAggregatedBooleanQuery>>>;
 export declare type AdaptableAlertAction = 'highlight-cell' | 'jump-to-cell' | 'jump-to-row' | 'jump-to-column' | 'suspend' | 'undo';
 /**
  * Defines a button that appears in an Alert Form

package/src/PredefinedConfig/Common/AdaptableQuery.d.ts

@@ -8,12 +8,15 @@ export interface AdaptableScalarQuery {
 export interface AdaptableObservableQuery {
     ObservableExpression: string;
 }
-export interface AdaptableAggregationQuery {
-    AggregationExpression: string;
+export interface AdaptableAggregatedBooleanQuery {
+    AggregatedBooleanExpression: string;
+}
+export interface AdaptableAggregatedScalarQuery {
+    AggregatedScalarExpression: string;
 }
 /**
- * An AdaptableQuery can be either a Boolean, Scalar, Observable or Aggregation expression
+ * An AdaptableQuery can be either a Boolean, Scalar, Observable, AggregatedBoolean, or AggregatedScalar expression
  */
-export declare type AdaptableQuery = XOR<AdaptableBooleanQuery, XOR<AdaptableScalarQuery, XOR<AdaptableObservableQuery, AdaptableAggregationQuery>>>;
+export declare type AdaptableQuery = XOR<AdaptableBooleanQuery, XOR<AdaptableScalarQuery, XOR<AdaptableObservableQuery, XOR<AdaptableAggregatedBooleanQuery, AdaptableAggregatedScalarQuery>>>>;
 export declare const getAdaptableQueryExpression: (query: Partial<AdaptableQuery>) => string | undefined;
 export declare const isReactiveQuery: (query: Partial<AdaptableQuery>) => boolean;

package/src/PredefinedConfig/Common/AdaptableQuery.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isReactiveQuery = exports.getAdaptableQueryExpression = void 0;
 exports.getAdaptableQueryExpression = (query) => {
-    var _a, _b, _c;
-    return ((_c = (_b = (_a = query.BooleanExpression) !== null && _a !== void 0 ? _a : query.ScalarExpression) !== null && _b !== void 0 ? _b : query.ObservableExpression) !== null && _c !== void 0 ? _c : query.AggregationExpression);
+    var _a, _b, _c, _d;
+    return ((_d = (_c = (_b = (_a = query.BooleanExpression) !== null && _a !== void 0 ? _a : query.ScalarExpression) !== null && _b !== void 0 ? _b : query.ObservableExpression) !== null && _c !== void 0 ? _c : query.AggregatedBooleanExpression) !== null && _d !== void 0 ? _d : query.AggregatedScalarExpression);
 };
 exports.isReactiveQuery = (query) => {
-    return !!query.ObservableExpression || !!query.AggregationExpression;
+    return !!query.ObservableExpression || !!query.AggregatedBooleanExpression;
 };

package/src/PredefinedConfig/Common/Enums.d.ts

@@ -1,7 +1,6 @@
 export declare enum DataType {
     String = "String",
     Number = "Number",
-    NumberArray = "NumberArray",
     Boolean = "Boolean",
     Date = "Date",
     Object = "Object",

package/src/PredefinedConfig/Common/Enums.js

@@ -6,8 +6,6 @@ var DataType;
 (function (DataType) {
     DataType["String"] = "String";
     DataType["Number"] = "Number";
-    // FIXME AFL keep it or extend it to support https://www.ag-grid.com/javascript-data-grid/sparklines-data/ ?
-    DataType["NumberArray"] = "NumberArray";
     DataType["Boolean"] = "Boolean";
     DataType["Date"] = "Date";
     DataType["Object"] = "Object";

package/src/Strategy/AlertModule.js

@@ -63,6 +63,7 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         return this.api.queryApi.getReferencedNamedQueryNames(queryExpression);
     }
     updateOldConfig() {
+        var _a;
         // 1. Make all (new) Flashing Alerts have a Predicate if none exists
         const alertState = this.api.alertApi.getAlertState();
         const flashingAlertDefinitions = alertState.FlashingAlertDefinitions;
@@ -73,6 +74,14 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             // TODO: state does not clear
             this.api.internalApi.clearFlashingCellState();
         }
+        //migrate alert definitions with `AggregationExpression` (now `AggregatedBooleanExpression`)
+        (_a = alertState.AlertDefinitions) === null || _a === void 0 ? void 0 : _a.forEach((alertDefinition) => {
+            // @ts-ignore
+            const obsoleteAggregationExpression = alertDefinition.Rule['AggregationExpression'];
+            if (obsoleteAggregationExpression) {
+                alertDefinition.Rule.AggregatedBooleanExpression = obsoleteAggregationExpression;
+            }
+        });
     }
     addContextMenuItems(menuContext) {
         const items = [];

package/src/Utilities/Defaults/DefaultAdaptableOptions.js

@@ -8,7 +8,7 @@ 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");
 exports.DefaultAdaptableOptions = {
@@ -212,7 +212,7 @@ exports.DefaultAdaptableOptions = {
         defaultBooleanFunctions: booleanExpressionFunctions_1.booleanExpressionFunctions,
         defaultScalarFunctions: scalarExpressionFunctions_1.scalarExpressionFunctions,
         defaultObservableFunctions: observableExpressionFunctions_1.observableExpressionFunctions,
-        defaultAggregationFunctions: aggregationExpressionFunctions_1.aggregationExpressionFunctions,
+        defaultAggregatedBooleanFunctions: aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions,
         moduleExpressionFunctions: undefined,
         queryableColumns: undefined,
         performExpressionValidation: true,

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);
@@ -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,7 @@
+import { ExpressionFunction } from '../../parser/src/types';
+import { BaseParameter } from './expressionFunctionUtils';
+export declare type AggregatedScalarFunctionName = 'CUMSUM' | 'OVER' | 'COL';
+export interface OverParameter extends BaseParameter<'operand', 'OVER'> {
+    value: string;
+}
+export declare const aggregatedScalarExpressionFunctions: Record<AggregatedScalarFunctionName, ExpressionFunction>;

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregatedScalarExpressionFunctions = void 0;
+const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+exports.aggregatedScalarExpressionFunctions = {
+    CUMSUM: {
+        handler(args, context) {
+            const cumulatedColumnParameter = expressionFunctionUtils_1.extractColumnParameter('SUM', args);
+            expressionFunctionUtils_1.validateColumnType(cumulatedColumnParameter.value, ['Number'], 'CUMSUM', context.api);
+            const overColumnParameter = expressionFunctionUtils_1.extractParameter('CUMSUM', 'operand', ['OVER'], args);
+            // sort over all rowNodes by overColumn
+            // cumulate
+            //save to map
+        },
+        description: 'TODO',
+        signatures: ['TODO'],
+        examples: ['TODO'],
+    },
+    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: 'TODO',
+        signatures: ['TODO'],
+        examples: ['TODO'],
+    },
+    COL: {
+        handler(args, context) {
+            return expressionFunctionUtils_1.handleColumnFunction(args, context);
+        },
+        description: 'Returns the value of a column',
+        signatures: ['[colName]', 'COL(name: string)'],
+        examples: ['[col1]', 'COL("col1")'],
+    },
+};

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 {};