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

package/src/Redux/Store/AdaptableStore.js

@@ -160,6 +160,17 @@ class AdaptableStore {
                 case exports.LOAD_STATE:
                     const { State } = action;
                     Object.keys(State).forEach((key) => {
+                        // this check should be removed in version 12 !!!
+                        if (key === 'Chart') {
+                            LoggingHelper_1.ConsoleLogWarning(`DEPRECATED: AdapTable Charts Plugin is deprecated! AG Grid built-in charts are fully supported & integrated in AdapTable.
+
+            Please contact 'support@adaptabletools.com' if you require any charting features that are not currently available.`);
+                        }
+                        if (key === 'SparklineColumn') {
+                            LoggingHelper_1.ConsoleLogWarning(`DEPRECATED: AdapTable SparklineColumn is deprecated! AG Grid built-in Sparklines are fully supported & integrated in AdapTable.
+
+            Please contact 'support@adaptabletools.com' if you require any sparklines features that are not currently available.`);
+                        }
                         state[key] = State[key];
                     });
                     break;
@@ -171,6 +182,7 @@ class AdaptableStore {
         // If the user has remote storage set then we use Remote Engine, otherwise we use Local Enginge
         // not sure we can do this as we need to be backwardly compatible with existing users so need to stick with adaptable id (which should be unique)
         // const localStorageKey =  'adaptable-adaptable-state-' + adaptable.adaptableOptions.primaryKey;
+        const predefinedConfig = adaptable.adaptableOptions.predefinedConfig;
         storageEngine = AdaptableReduxLocalStorageEngine_1.createEngine({
             adaptableId: adaptable.adaptableOptions.adaptableId,
             adaptableStateKey: adaptable.adaptableOptions.adaptableStateKey,
@@ -305,9 +317,9 @@ const adaptableMiddleware = (adaptable) => function (middlewareAPI) {
                 /*******************
                  * FLASHING ALERT ACTIONS
                  *******************/
-                case SystemRedux.SYSTEM_FLASHING_ALERT_ADD:
-                case SystemRedux.SYSTEM_FLASHING_ALERT_DELETE: {
-                    const { flashingCell: FlashingCell, } = action;
+                case SystemRedux.SYSTEM_FLASHING_CELL_ADD:
+                case SystemRedux.SYSTEM_FLASHING_CELL_DELETE: {
+                    const { flashingCell: FlashingCell } = action;
                     const { dataChangedInfo } = FlashingCell;
                     let ret = next(action);
                     if (dataChangedInfo) {
@@ -1075,7 +1087,7 @@ const adaptableMiddleware = (adaptable) => function (middlewareAPI) {
                 case TeamSharingRedux.TEAMSHARING_IMPORT_ITEM: {
                     let returnAction = next(action);
                     const actionTyped = action;
-                    const [importStepActions, needsOverwriteConfirmation,] = adaptable.api.internalApi
+                    const [importStepActions, needsOverwriteConfirmation] = adaptable.api.internalApi
                         .getTeamSharingService()
                         .buildSharedEntityImportActions(actionTyped.SharedEntity);
                     const processImportAction = TeamSharingRedux.TeamSharingProcessImport(importStepActions);
@@ -1148,14 +1160,14 @@ const adaptableMiddleware = (adaptable) => function (middlewareAPI) {
                         .getSharedEntities(adaptableId)
                         .then((sharedEntities) => {
                         // check if remote server has a newer revision
-                        const [localRevision, remoteRevision,] = adaptable.api.internalApi
+                        const [localRevision, remoteRevision] = adaptable.api.internalApi
                             .getTeamSharingService()
                             .getSharedEntityLocalAndRemoteRevisions(ChangedAdaptableObject.Uuid, sharedEntities);
                         if (remoteRevision > localRevision) {
                             // if remote has a newer version, we will NOT overwrite it
                             return;
                         }
-                        const [updatedSharedEntities, newActiveEntities,] = adaptable.api.internalApi
+                        const [updatedSharedEntities, newActiveEntities] = adaptable.api.internalApi
                             .getTeamSharingService()
                             .updateActiveSharedEntity(ChangedAdaptableObject, UserName, sharedEntities);
                         middlewareAPI.dispatch(TeamSharingRedux.TeamSharingLinkItem(...newActiveEntities));

package/src/Strategy/AlertModule.js

@@ -19,12 +19,12 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.AlertModuleId, 'Alert', 'alert', 'AlertPopup', 'Get notified when things happen in Adaptable that you need to know about', api);
         this.api.internalApi.getDataService().on('DataChanged', (dataChangedInfo) => {
-            if (dataChangedInfo.trigger === 'undo') {
+            if (dataChangedInfo.trigger === 'undo' || dataChangedInfo.trigger === 'aggChange') {
                 // do NOT handle reverted changes
                 return;
             }
-            if (this.api.internalApi.getAdaptableOptions().notificationsOptions
-                .dataChangeDetectionPolicy === 'formattedValue') {
+            if (this.api.internalApi.getAdaptableOptions().alertOptions.dataChangeDetectionPolicy ===
+                'formattedValue') {
                 const { oldValue, newValue } = dataChangedInfo;
                 const columnId = dataChangedInfo.column.columnId;
                 const oldFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(columnId, oldValue);
@@ -63,8 +63,10 @@ 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 flashingAlertDefinitions = this.api.alertApi.getAlertState().FlashingAlertDefinitions;
+        const alertState = this.api.alertApi.getAlertState();
+        const flashingAlertDefinitions = alertState.FlashingAlertDefinitions;
         const flashingCellDefinitions = this.api.flashingCellApi.getFlashingCellDefinitions();
         if (ArrayExtensions_1.ArrayExtensions.IsEmpty(flashingCellDefinitions) &&
             ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(flashingAlertDefinitions)) {
@@ -72,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/Strategy/ConditionalStyleModule.js

@@ -191,6 +191,10 @@ class ConditionalStyleModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                 getScopeViewItems_1.getScopeViewItems(conditionalStyle.Scope),
                 getStyleViewItems_1.getStyleViewItems(),
                 getRuleViewItems_1.getRuleViewItems(conditionalStyle.Rule, this.api),
+                {
+                    name: 'Settings',
+                    values: [`Include grouped rows: ${conditionalStyle.IncludeGroupedRows ? 'Yes' : 'No'}`],
+                },
             ],
             abObject: conditionalStyle,
         };

package/src/Strategy/DataChangeHistoryModule.js

@@ -9,7 +9,7 @@ class DataChangeHistoryModule extends AdaptableModuleBase_1.AdaptableModuleBase
     constructor(api) {
         super(ModuleConstants.DataChangeHistoryModuleId, 'Data Changes', 'track-changes', 'DataChangeHistoryPopup', 'Provides an overview of all previous changes, giving the possibility to undo specific changes', api);
         this.api.internalApi.getDataService().on('DataChanged', (dataChangedInfo) => {
-            if (dataChangedInfo.trigger !== 'undo') {
+            if (dataChangedInfo.trigger !== 'undo' && dataChangedInfo.trigger !== 'aggChange') {
                 if (this.shouldLogDataChange(dataChangedInfo)) {
                     this.api.internalApi.dispatchReduxAction(SystemRedux_1.SystemDataChangeHistoryAdd(dataChangedInfo));
                 }

package/src/Strategy/FlashingCellModule.d.ts

@@ -18,8 +18,8 @@ export declare class FlashingCellModule extends AdaptableModuleBase implements I
     addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
     protected handleDataSourceChanged(dataChangedInfo: DataChangedInfo): void;
     private showFlashingCellsForDefinitions;
+    private isFlashingTargetOnlyAggChange;
     private getFlashingCellDefinitionsForDataChange;
-    private getBaseAlertDefinitionsForDataChange;
     private isAlertPredicateTriggered;
     getTeamSharingAction(): TeamSharingImportInfo<FlashingCellDefinition>;
     toView(flashingCell: FlashingCellDefinition): AdaptableObjectView;

package/src/Strategy/FlashingCellModule.js

@@ -24,8 +24,8 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             }
             // TODO: think about flashing row value only
             // - flash for the underlying small data changes, but the visual does not
-            if (this.api.internalApi.getAdaptableOptions().notificationsOptions
-                .dataChangeDetectionPolicy === 'formattedValue') {
+            if (this.api.internalApi.getAdaptableOptions().alertOptions.dataChangeDetectionPolicy ===
+                'formattedValue') {
                 const { oldValue, newValue } = dataChangedInfo;
                 const columnId = dataChangedInfo.column.columnId;
                 const oldFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(columnId, oldValue);
@@ -123,9 +123,13 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             direction = up ? 'up' : down ? 'down' : 'neutral';
         }
         flashingCellDefinitions.forEach((flashingCellDefinition) => {
-            const flashTarget = this.api.flashingCellApi.getFlashingCellFlashTarget(flashingCellDefinition);
+            var _a;
+            let flashTarget = this.api.flashingCellApi.getFlashingCellFlashTarget(flashingCellDefinition);
             const flashColumnIds = { [dataChangedInfo.column.columnId]: true };
-            if (flashTarget === 'row') {
+            /**
+             * When flashing a row, all columns in that row are marked to flash.
+             */
+            if (flashTarget === 'row' || ((_a = flashTarget === null || flashTarget === void 0 ? void 0 : flashTarget.includes) === null || _a === void 0 ? void 0 : _a.call(flashTarget, 'row'))) {
                 allColumnIds.forEach((colId) => {
                     flashColumnIds[colId] = true;
                 });
@@ -141,18 +145,30 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             });
         });
     }
-    getFlashingCellDefinitionsForDataChange(dataChangedEvent) {
-        return this.getBaseAlertDefinitionsForDataChange(dataChangedEvent, this.api.flashingCellApi.getActiveFlashingCellDefinitions(), true);
+    isFlashingTargetOnlyAggChange(flashingCellDefinition) {
+        if (flashingCellDefinition.FlashTarget === 'aggFuncCell') {
+            return true;
+        }
+        return (Array.isArray(flashingCellDefinition.FlashTarget) &&
+            flashingCellDefinition.FlashTarget.length === 1 &&
+            flashingCellDefinition.FlashTarget.includes('aggFuncCell'));
     }
-    getBaseAlertDefinitionsForDataChange(dataChangedEvent, definitions, defaultNoPredicateReturn = false) {
-        let relatedAlertDefinitions = definitions
+    getFlashingCellDefinitionsForDataChange(dataChangedEvent) {
+        const definitions = this.api.flashingCellApi.getActiveFlashingCellDefinitions();
+        const defaultNoPredicateReturn = false;
+        let relatedFlashingCellsDefinitions = definitions
             .filter((v) => this.api.scopeApi.isColumnInScope(dataChangedEvent.column, v.Scope))
             .filter((flashingCellDefinition) => !AdaptableQuery_1.isReactiveQuery(flashingCellDefinition.Rule));
-        let triggeredAlerts = [];
-        if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(relatedAlertDefinitions)) {
-            relatedAlertDefinitions.forEach((alertDefinition) => {
-                if (alertDefinition.Rule.BooleanExpression) {
-                    let expression = alertDefinition.Rule.BooleanExpression;
+        let triggeredFlashingCells = [];
+        if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(relatedFlashingCellsDefinitions)) {
+            relatedFlashingCellsDefinitions.forEach((flashingCellDefinition) => {
+                // for aggregation the data-change needs to be aggChange
+                if (dataChangedEvent.trigger !== 'aggChange' &&
+                    this.isFlashingTargetOnlyAggChange(flashingCellDefinition)) {
+                    return;
+                }
+                if (flashingCellDefinition.Rule.BooleanExpression) {
+                    let expression = flashingCellDefinition.Rule.BooleanExpression;
                     let rowNode = dataChangedEvent.rowNode;
                     if (!rowNode) {
                         rowNode = this.api.gridApi.getRowNodeForPrimaryKey(dataChangedEvent.primaryKeyValue);
@@ -163,15 +179,15 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                             .getQueryLanguageService()
                             .evaluateBooleanExpression(expression, this.moduleInfo.ModuleName, rowNode);
                     if (isSatisfiedExpression) {
-                        triggeredAlerts.push(alertDefinition);
+                        triggeredFlashingCells.push(flashingCellDefinition);
                     }
                 }
-                else if (this.isAlertPredicateTriggered(alertDefinition, dataChangedEvent, defaultNoPredicateReturn)) {
-                    triggeredAlerts.push(alertDefinition);
+                else if (this.isAlertPredicateTriggered(flashingCellDefinition, dataChangedEvent, defaultNoPredicateReturn)) {
+                    triggeredFlashingCells.push(flashingCellDefinition);
                 }
             });
         }
-        return triggeredAlerts;
+        return triggeredFlashingCells;
     }
     isAlertPredicateTriggered(alert, dataChangedEvent, defaultNoPredicateReturn = false) {
         return this.api.predicateApi.handlePredicate(alert.Rule.Predicate, {
@@ -194,7 +210,7 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         return {
             items: [
                 Object.assign(Object.assign({}, getScopeViewItems_1.getScopeViewItems(flashingCell.Scope)), { label: 'Trigger' }),
-                getRuleViewItems_1.getRuleViewItems(flashingCell.Rule, this.api),
+                Object.assign(Object.assign({}, getRuleViewItems_1.getRuleViewItems(flashingCell.Rule, this.api)), { label: 'Rule', name: 'Rule' }),
                 getFlashingCellDurationViewItems_1.getFlashingCellDurationViewItems(flashingCell),
                 getFlashingTargetViewItems_1.getFlashingTargetViewItems(flashingCell),
                 getFlashingCellStyleViewItems_1.getFlashingCellStyleViewItems(),

package/src/Strategy/FreeTextColumnModule.d.ts

@@ -7,12 +7,12 @@ import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { FreeTextColumn } from '../PredefinedConfig/FreeTextColumnState';
 import { AdaptableObjectView, IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
-import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
 export declare class FreeTextColumnModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
     isModuleAvailable(): boolean;
-    getModuleAdaptableObjects(): AdaptableObject[];
+    getModuleAdaptableObjects(): FreeTextColumn[];
     hasNamedQueryReferences(): boolean;
+    updateOldConfig(): void;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     getTeamSharingAction(): TeamSharingImportInfo<FreeTextColumn>;
     toView(freeTextColumn: FreeTextColumn): AdaptableObjectView;

package/src/Strategy/FreeTextColumnModule.js

@@ -21,6 +21,16 @@ class FreeTextColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     hasNamedQueryReferences() {
         return false;
     }
+    updateOldConfig() {
+        // make sure all default to type string
+        const allFreeTextColumns = this.getModuleAdaptableObjects();
+        for (const freeTextColumn of allFreeTextColumns) {
+            if (!freeTextColumn.DataType) {
+                const updatedFreeTextColumn = Object.assign(Object.assign({}, freeTextColumn), { DataType: 'String' });
+                this.api.freeTextColumnApi.editFreeTextColumn(updatedFreeTextColumn);
+            }
+        }
+    }
     addColumnMenuItems(column) {
         if (column && this.isModuleEditable()) {
             if (this.api.freeTextColumnApi

package/src/Strategy/LayoutModule.js

@@ -48,12 +48,7 @@ class LayoutModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             }
             if (column) {
                 if (!isReadOnlyLayout) {
-                    returnColumnMenuItems.push(this.createColumnMenuItemClickFunction('Change Caption', 'edit', () => {
-                        let newname = prompt('Enter a new Caption for the Column');
-                        if (newname) {
-                            this.api.layoutApi.setColumnCaption(column.columnId, newname);
-                        }
-                    }));
+                    returnColumnMenuItems.push(this.createColumnMenuItemClickFunction('Change Caption', 'edit', () => this.api.layoutApi.showChangeColumnCaption(column)));
                 }
                 if (column.hideable) {
                     returnColumnMenuItems.push(this.createColumnMenuItemClickFunction('Hide Column', 'hide-column', () => {

package/src/Strategy/TeamSharingModule.js

@@ -7,7 +7,7 @@ const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/Mod
 const isAdaptableObject_1 = require("../Utilities/isAdaptableObject");
 const TeamSharingRedux_1 = require("../Redux/ActionsReducers/TeamSharingRedux");
 const TeamSharingRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/TeamSharingRedux"));
-const isEqual_1 = tslib_1.__importDefault(require("lodash-es/isEqual"));
+const isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
 const LayoutRedux_1 = require("../Redux/ActionsReducers/LayoutRedux");
 class TeamSharingModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {

package/src/Strategy/ToolPanelModule.js

@@ -15,8 +15,7 @@ class ToolPanelModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         if (!super.isModuleAvailable()) {
             return false;
         }
-        const toolPanelOptions = this.api.internalApi.getAdaptableOptions()
-            .toolPanelOptions;
+        const toolPanelOptions = this.api.internalApi.getAdaptableOptions().toolPanelOptions;
         return (toolPanelOptions &&
             toolPanelOptions.showAdaptableToolPanel &&
             toolPanelOptions.showAdaptableToolPanel == true);
@@ -25,7 +24,10 @@ class ToolPanelModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         const deprecatedToolPanelConfigs = this.api.toolPanelApi.getToolPanelState().VisibleToolPanels;
         if (deprecatedToolPanelConfigs === null || deprecatedToolPanelConfigs === void 0 ? void 0 : deprecatedToolPanelConfigs.length) {
             LoggingHelper_1.LogAdaptableWarning(`Updating Obsolete VisibleToolPanels Config for ToolPanelState: [${deprecatedToolPanelConfigs}]`);
-            const migratedToolPanelConfigs = deprecatedToolPanelConfigs.map((toolPanel) => ({ Name: toolPanel, State: 'collapsed' }));
+            const migratedToolPanelConfigs = deprecatedToolPanelConfigs.map((toolPanel) => ({
+                Name: toolPanel,
+                State: 'collapsed',
+            }));
             this.api.internalApi.dispatchReduxAction(ToolPanelRedux_1.ToolPanelSetToolPanels(migratedToolPanelConfigs));
         }
         else if (!this.api.toolPanelApi.getToolPanelState().ToolPanels) {

package/src/Strategy/Utilities/getFlashingTargetViewItems.d.ts

@@ -1,5 +1,5 @@
 import { FlashingCellDefinition } from '../../../types';
 export declare const getFlashingTargetViewItems: (flashingCell: FlashingCellDefinition) => {
     name: string;
-    values: ("cell" | "row")[];
+    values: import("../../PredefinedConfig/FlashingCellState").FlashTargetTypes[];
 };

package/src/Strategy/Utilities/getFlashingTargetViewItems.js

@@ -4,6 +4,8 @@ exports.getFlashingTargetViewItems = void 0;
 exports.getFlashingTargetViewItems = (flashingCell) => {
     return {
         name: 'Target',
-        values: [flashingCell.FlashTarget],
+        values: Array.isArray(flashingCell.FlashTarget)
+            ? flashingCell.FlashTarget
+            : [flashingCell.FlashTarget],
     };
 };

package/src/Strategy/Utilities/getFormatColumnSettingsViewItems.js

@@ -6,7 +6,7 @@ exports.getFormatColumnSettingsViewItems = (calculatedColumn) => {
     const values = [
         `Cell alignment: ${(_a = calculatedColumn.CellAlignment) !== null && _a !== void 0 ? _a : 'default'}`,
         calculatedColumn.HeaderName && `Header name: ${calculatedColumn.HeaderName}`,
-        `Include grouped rows: ${calculatedColumn.IncludeGroupedRows ? 'yes' : 'no'}`,
+        `Include grouped rows: ${calculatedColumn.IncludeGroupedRows ? 'Yes' : 'No'}`,
     ].filter(Boolean);
     return {
         name: 'Settings',

package/src/Strategy/Utilities/getRuleViewItems.d.ts

@@ -1,6 +1,5 @@
 import { AdaptableApi } from '../../../types';
 export declare const getRuleViewItems: (rule: any, api: AdaptableApi) => {
     name: string;
-    label: string;
     values: string[];
 };

package/src/Strategy/Utilities/getRuleViewItems.js

@@ -5,7 +5,6 @@ const AdaptableQuery_1 = require("../../PredefinedConfig/Common/AdaptableQuery")
 exports.getRuleViewItems = (rule, api) => {
     return {
         name: 'Condition',
-        label: 'Condition',
         values: [
             rule.Predicate
                 ? api.predicateApi.predicateToString(rule.Predicate)

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 = {
@@ -19,20 +19,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,
@@ -210,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,9 +1,9 @@
 "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-es/parseInt"));
+const parseInt_1 = tslib_1.__importDefault(require("lodash/parseInt"));
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const operators_1 = require("rxjs/operators");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
@@ -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/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 {};