@adaptabletools/adaptable 18.0.0-canary.2 → 18.0.0-canary.21

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -1,63 +1,6 @@
 import cloneDeepWith from 'lodash/cloneDeepWith';
 import isPlainObject from 'lodash/isPlainObject';
 import { createUuid } from '../../PredefinedConfig/Uuid';
-import { DefaultAdaptableOptions } from '../Defaults/DefaultAdaptableOptions';
-export function assignAdaptableOptions(adaptableOptions) {
-    var _a;
-    const returnedAdaptableOptions = Object.assign({}, DefaultAdaptableOptions, adaptableOptions);
-    returnedAdaptableOptions.adaptableStateKey =
-        (_a = returnedAdaptableOptions.adaptableStateKey) !== null && _a !== void 0 ? _a : returnedAdaptableOptions.adaptableId;
-    returnedAdaptableOptions.dataImportOptions = Object.assign({}, DefaultAdaptableOptions.dataImportOptions, adaptableOptions.dataImportOptions);
-    returnedAdaptableOptions.expressionOptions = Object.assign({}, DefaultAdaptableOptions.expressionOptions, adaptableOptions.expressionOptions);
-    returnedAdaptableOptions.calendarOptions = Object.assign({}, DefaultAdaptableOptions.calendarOptions, adaptableOptions.calendarOptions);
-    returnedAdaptableOptions.columnOptions = Object.assign({}, DefaultAdaptableOptions.columnOptions, adaptableOptions.columnOptions);
-    returnedAdaptableOptions.customSortOptions = Object.assign({}, DefaultAdaptableOptions.customSortOptions, adaptableOptions.customSortOptions);
-    returnedAdaptableOptions.dataSetOptions = Object.assign({}, DefaultAdaptableOptions.dataSetOptions, adaptableOptions.dataSetOptions);
-    returnedAdaptableOptions.cellSummaryOptions = Object.assign({}, DefaultAdaptableOptions.cellSummaryOptions, adaptableOptions.cellSummaryOptions);
-    returnedAdaptableOptions.predicateOptions = Object.assign({}, DefaultAdaptableOptions.predicateOptions, returnedAdaptableOptions.predicateOptions);
-    returnedAdaptableOptions.layoutOptions = Object.assign({}, DefaultAdaptableOptions.layoutOptions, adaptableOptions.layoutOptions);
-    returnedAdaptableOptions.notificationsOptions = Object.assign({}, DefaultAdaptableOptions.notificationsOptions, adaptableOptions.notificationsOptions);
-    returnedAdaptableOptions.alertOptions = Object.assign({}, DefaultAdaptableOptions.alertOptions, adaptableOptions.alertOptions);
-    returnedAdaptableOptions.flashingCellOptions = Object.assign({}, DefaultAdaptableOptions.flashingCellOptions, adaptableOptions.flashingCellOptions);
-    returnedAdaptableOptions.entitlementOptions = Object.assign({}, DefaultAdaptableOptions.entitlementOptions, adaptableOptions.entitlementOptions);
-    returnedAdaptableOptions.dashboardOptions = Object.assign({}, DefaultAdaptableOptions.dashboardOptions, adaptableOptions.dashboardOptions);
-    returnedAdaptableOptions.editOptions = Object.assign({}, DefaultAdaptableOptions.editOptions, adaptableOptions.editOptions);
-    returnedAdaptableOptions.actionColumnOptions = Object.assign({}, DefaultAdaptableOptions.actionColumnOptions, adaptableOptions.actionColumnOptions);
-    // to do
-    returnedAdaptableOptions.actionRowOptions = Object.assign({}, DefaultAdaptableOptions.actionRowOptions, adaptableOptions.actionRowOptions);
-    returnedAdaptableOptions.actionRowOptions.actionRowButtonOptions = Object.assign({}, DefaultAdaptableOptions.actionRowOptions.actionRowButtonOptions, returnedAdaptableOptions.actionRowOptions.actionRowButtonOptions);
-    returnedAdaptableOptions.actionRowOptions.actionRowFormOptions = Object.assign({}, DefaultAdaptableOptions.actionRowOptions.actionRowFormOptions, returnedAdaptableOptions.actionRowOptions.actionRowFormOptions);
-    returnedAdaptableOptions.containerOptions = Object.assign({}, DefaultAdaptableOptions.containerOptions, adaptableOptions.containerOptions);
-    returnedAdaptableOptions.groupingOptions = Object.assign({}, DefaultAdaptableOptions.groupingOptions, adaptableOptions.groupingOptions);
-    returnedAdaptableOptions.quickSearchOptions = Object.assign({}, DefaultAdaptableOptions.quickSearchOptions, adaptableOptions.quickSearchOptions);
-    returnedAdaptableOptions.columnFilterOptions = Object.assign({}, DefaultAdaptableOptions.columnFilterOptions, adaptableOptions.columnFilterOptions);
-    returnedAdaptableOptions.columnFilterOptions.quickFilterOptions = Object.assign({}, DefaultAdaptableOptions.columnFilterOptions.quickFilterOptions, returnedAdaptableOptions.columnFilterOptions.quickFilterOptions);
-    returnedAdaptableOptions.columnFilterOptions.filterFormOptions = Object.assign({}, DefaultAdaptableOptions.columnFilterOptions.filterFormOptions, returnedAdaptableOptions.columnFilterOptions.filterFormOptions);
-    returnedAdaptableOptions.columnFilterOptions.valuesFilterOptions = Object.assign({}, DefaultAdaptableOptions.columnFilterOptions.valuesFilterOptions, returnedAdaptableOptions.columnFilterOptions.valuesFilterOptions);
-    returnedAdaptableOptions.gridFilterOptions = Object.assign({}, DefaultAdaptableOptions.gridFilterOptions, adaptableOptions.gridFilterOptions);
-    returnedAdaptableOptions.userInterfaceOptions = Object.assign({}, DefaultAdaptableOptions.userInterfaceOptions, adaptableOptions.userInterfaceOptions);
-    returnedAdaptableOptions.userInterfaceOptions.dateInputOptions = Object.assign({}, DefaultAdaptableOptions.userInterfaceOptions.dateInputOptions, returnedAdaptableOptions.userInterfaceOptions.dateInputOptions);
-    returnedAdaptableOptions.menuOptions = Object.assign({}, DefaultAdaptableOptions.menuOptions, adaptableOptions.menuOptions);
-    returnedAdaptableOptions.stateOptions = Object.assign({}, DefaultAdaptableOptions.stateOptions, adaptableOptions.stateOptions);
-    returnedAdaptableOptions.exportOptions = Object.assign({}, DefaultAdaptableOptions.exportOptions, adaptableOptions.exportOptions);
-    returnedAdaptableOptions.teamSharingOptions = Object.assign({}, DefaultAdaptableOptions.teamSharingOptions, adaptableOptions.teamSharingOptions);
-    returnedAdaptableOptions.toolPanelOptions = Object.assign({}, DefaultAdaptableOptions.toolPanelOptions, adaptableOptions.toolPanelOptions);
-    returnedAdaptableOptions.dataChangeHistoryOptions = Object.assign({}, DefaultAdaptableOptions.dataChangeHistoryOptions, adaptableOptions.dataChangeHistoryOptions);
-    returnedAdaptableOptions.chartingOptions = Object.assign({}, DefaultAdaptableOptions.chartingOptions, adaptableOptions.chartingOptions);
-    returnedAdaptableOptions.chartingOptions.externalChartingOptions = Object.assign({}, DefaultAdaptableOptions.chartingOptions.externalChartingOptions, returnedAdaptableOptions.chartingOptions.externalChartingOptions);
-    returnedAdaptableOptions.settingsPanelOptions = Object.assign({}, DefaultAdaptableOptions.settingsPanelOptions, adaptableOptions.settingsPanelOptions);
-    returnedAdaptableOptions.fdc3Options = Object.assign({}, DefaultAdaptableOptions.fdc3Options, adaptableOptions.fdc3Options);
-    returnedAdaptableOptions.fdc3Options.actionColumnDefaultConfiguration = Object.assign({}, DefaultAdaptableOptions.fdc3Options.actionColumnDefaultConfiguration, returnedAdaptableOptions.fdc3Options.actionColumnDefaultConfiguration);
-    returnedAdaptableOptions.fdc3Options.uiControlsDefaultConfiguration = Object.assign({}, DefaultAdaptableOptions.fdc3Options.uiControlsDefaultConfiguration, returnedAdaptableOptions.fdc3Options.uiControlsDefaultConfiguration);
-    const { predefinedConfig } = returnedAdaptableOptions;
-    if (predefinedConfig) {
-        returnedAdaptableOptions.predefinedConfig =
-            typeof predefinedConfig === 'string'
-                ? predefinedConfig
-                : initPredefinedConfigWithUuids(predefinedConfig);
-    }
-    return returnedAdaptableOptions;
-}
 export function initPredefinedConfigWithUuids(predefinedConfig) {
     const customizer = (value) => {
         // so whenever we clone a plain object,
@@ -143,13 +86,30 @@ export function addUuidAndSource(adaptableObject) {
     adaptableObject.Source = 'User';
     return adaptableObject;
 }
+export function removeUuidAndSource(adaptableObject) {
+    const sanitiseObject = (object) => {
+        for (const key in object) {
+            if (key === 'Source' || key === 'Uuid') {
+                delete object[key];
+            }
+            else if (Array.isArray(object[key])) {
+                object[key].forEach((item) => sanitiseObject(item));
+            }
+            else if (typeof object[key] === 'object') {
+                sanitiseObject(object[key]);
+            }
+        }
+    };
+    sanitiseObject(adaptableObject);
+    return adaptableObject;
+}
 export const AdaptableHelper = {
-    assignAdaptableOptions,
     initPredefinedConfigWithUuids,
     checkValidPrimaryKey,
     AdaptableObjectExistsInState,
     runAdaptableComparerFunction,
     getAppropriateAccessLevel,
     addUuidAndSource,
+    removeUuidAndSource,
 };
 export default AdaptableHelper;

package/src/Utilities/Helpers/Helper.d.ts

@@ -1,5 +1,6 @@
 export declare function objectExists(item: any): boolean;
 export declare function objectNotExists(item: any): boolean;
+export declare function objectHasKeys(item: any): boolean;
 export declare function getStringRepresentionFromKey(event: KeyboardEvent | any): string;
 export declare function cloneObject<T extends any>(obj: T): T;
 export declare const arrayToKeyMap: <T extends string | number | symbol>(arr?: T[]) => Record<T, boolean>;
@@ -20,6 +21,7 @@ export declare function clamp(value: any, boundOne: number, boundTwo: number): n
 export declare const Helper: {
     objectExists: typeof objectExists;
     objectNotExists: typeof objectNotExists;
+    objectHasKeys: typeof objectHasKeys;
     getStringRepresentionFromKey: typeof getStringRepresentionFromKey;
     cloneObject: typeof cloneObject;
     convertArrayToCsv: typeof convertArrayToCsv;

package/src/Utilities/Helpers/Helper.js

@@ -6,6 +6,9 @@ export function objectExists(item) {
 export function objectNotExists(item) {
     return !objectExists(item);
 }
+export function objectHasKeys(item) {
+    return Object.keys(item).length > 0;
+}
 export function getStringRepresentionFromKey(event) {
     if (event.key == null) {
         return event.char; // IE
@@ -227,6 +230,7 @@ export function clamp(value, boundOne, boundTwo) {
 export const Helper = {
     objectExists,
     objectNotExists,
+    objectHasKeys,
     getStringRepresentionFromKey,
     cloneObject,
     convertArrayToCsv,

package/src/Utilities/MenuItem.d.ts

@@ -1,10 +1,11 @@
 import * as Redux from 'redux';
 import { ModuleParams } from '../View/Components/SharedProps/ModuleViewPopupProps';
-import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
+import { AdaptableMenuItem, AdaptableContextMenuItemName, AdaptableColumnMenuItemName } from '../PredefinedConfig/Common/Menu';
 import { AdaptableModule } from '../PredefinedConfig/Common/Types';
 import { AdaptableIcon, AdaptableSystemIconName } from '../PredefinedConfig/Common/AdaptableIcon';
 export declare class MenuItemDoReduxAction implements AdaptableMenuItem {
-    constructor(label: string, module: AdaptableModule, reduxAction: Redux.Action, icon: AdaptableSystemIconName, isVisible: boolean);
+    constructor(name: AdaptableColumnMenuItemName | AdaptableContextMenuItemName, label: string, module: AdaptableModule, reduxAction: Redux.Action, icon: AdaptableSystemIconName, isVisible: boolean);
+    name: AdaptableColumnMenuItemName | AdaptableContextMenuItemName;
     reduxAction: Redux.Action;
     label: string;
     module: AdaptableModule;
@@ -12,7 +13,8 @@ export declare class MenuItemDoReduxAction implements AdaptableMenuItem {
     icon: AdaptableIcon;
 }
 export declare class MenuItemDoClickFunction implements AdaptableMenuItem {
-    constructor(label: string, module: AdaptableModule, clickFunction: () => void, icon: AdaptableSystemIconName, isVisible: boolean);
+    constructor(name: AdaptableColumnMenuItemName | AdaptableContextMenuItemName, label: string, module: AdaptableModule, clickFunction: () => void, icon: AdaptableSystemIconName, isVisible: boolean);
+    name: AdaptableColumnMenuItemName | AdaptableContextMenuItemName;
     onClick: () => void;
     label: string;
     module: AdaptableModule;
@@ -20,7 +22,8 @@ export declare class MenuItemDoClickFunction implements AdaptableMenuItem {
     icon: AdaptableIcon;
 }
 export declare class MenuItemShowPopup implements AdaptableMenuItem {
-    constructor(label: string, module: AdaptableModule, componentName: string, icon: AdaptableSystemIconName, isVisible: boolean, popupParams?: ModuleParams);
+    constructor(name: AdaptableColumnMenuItemName | AdaptableContextMenuItemName, label: string, module: AdaptableModule, componentName: string, icon: AdaptableSystemIconName, isVisible: boolean, popupParams?: ModuleParams);
+    name: AdaptableColumnMenuItemName | AdaptableContextMenuItemName;
     reduxAction: Redux.Action;
     label: string;
     module: AdaptableModule;

package/src/Utilities/MenuItem.js

@@ -1,7 +1,8 @@
 import * as PopupRedux from '../Redux/ActionsReducers/PopupRedux';
 // A menu item which performs a Redux Action when it is clicke
 export class MenuItemDoReduxAction {
-    constructor(label, module, reduxAction, icon, isVisible) {
+    constructor(name, label, module, reduxAction, icon, isVisible) {
+        this.name = name;
         this.label = label;
         this.module = module;
         this.isVisible = isVisible;
@@ -12,7 +13,8 @@ export class MenuItemDoReduxAction {
     }
 }
 export class MenuItemDoClickFunction {
-    constructor(label, module, clickFunction, icon, isVisible) {
+    constructor(name, label, module, clickFunction, icon, isVisible) {
+        this.name = name;
         this.label = label;
         this.module = module;
         this.isVisible = isVisible;
@@ -24,7 +26,8 @@ export class MenuItemDoClickFunction {
 }
 // A menu item which shows a popup screen when it is clieked
 export class MenuItemShowPopup {
-    constructor(label, module, componentName, icon, isVisible, popupParams) {
+    constructor(name, label, module, componentName, icon, isVisible, popupParams) {
+        this.name = name;
         this.label = label;
         this.module = module;
         this.isVisible = isVisible;

package/src/Utilities/ObjectFactory.d.ts

@@ -21,14 +21,14 @@ import { Shortcut } from '../PredefinedConfig/ShortcutState';
 import { IPushPullReport } from '../PredefinedConfig/SystemState';
 import { NotificationsOptions } from '../AdaptableOptions/NotificationsOptions';
 import { CellSummmary } from '../PredefinedConfig/Common/CellSummary';
-import { AdaptableTheme, BaseContext, ChartDefinition, ColumnFilter, CommentThread, CustomDisplayFormatterContext, FlashingCellDefinition, GridDataChangedInfo, SystemFilterPredicateId } from '../types';
+import { AdaptableTheme, BaseContext, ChartDefinition, ColumnFilter, CommentThread, CustomDisplayFormatterContext, FlashingCellDefinition, GridDataChangedInfo, SpecialColumnSettings, SystemFilterPredicateId } from '../types';
 import { IRowNode } from '@ag-grid-community/core';
 import { AdaptableApi, AdaptableComment, BadgeStyleDefinition, CellAddress, NamedQuery } from '../../types';
 import { ToastOptions } from '../components/Toastify';
 import { StyledColumn } from '../PredefinedConfig/StyledColumnState';
 export declare function CreateEmptyCustomSort(): CustomSort;
 export declare function CreateAdaptableComment(text: string, api: AdaptableApi): AdaptableComment;
-export declare function CreateEmptyCalculatedColumn(): CalculatedColumn;
+export declare function CreateEmptyCalculatedColumn(defaultSpecialColumnSettings: Partial<SpecialColumnSettings>): CalculatedColumn;
 export declare function CreateEmptyNamedQuery(expression?: string): NamedQuery;
 export declare function CreateEmptyPlusMinusNudge(): PlusMinusNudge;
 export declare function CreateGenericAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition): AdaptableGenericAlert;
@@ -51,7 +51,7 @@ export declare function CreateReportSchedule(reportName: string): ReportSchedule
 export declare function CreateEmptySchedule(): Schedule;
 export declare function CreateEmptyShortcut(): Shortcut;
 export declare function CreateEmptyFormatColumn(): FormatColumn;
-export declare function CreateEmptyFreeTextColumn(): FreeTextColumn;
+export declare function CreateEmptyFreeTextColumn(defaultSpecialColumnSettings: Partial<SpecialColumnSettings>): FreeTextColumn;
 export declare function CreateEmptyLayout(layout?: Partial<Layout> & {
     Name: string;
 }, adaptableColumns?: AdaptableColumn[]): Layout;

package/src/Utilities/ObjectFactory.js

@@ -18,7 +18,7 @@ export function CreateAdaptableComment(text, api) {
     };
     return comment;
 }
-export function CreateEmptyCalculatedColumn() {
+export function CreateEmptyCalculatedColumn(defaultSpecialColumnSettings) {
     return {
         Uuid: createUuid(),
         ColumnId: EMPTY_STRING,
@@ -26,17 +26,7 @@ export function CreateEmptyCalculatedColumn() {
             ScalarExpression: EMPTY_STRING,
         },
         // need to create some defaults - which we will change later
-        CalculatedColumnSettings: {
-            DataType: undefined,
-            Filterable: false,
-            Resizable: false,
-            Groupable: false,
-            Sortable: false,
-            Pivotable: false,
-            Aggregatable: false,
-            SuppressMenu: false,
-            SuppressMovable: false,
-        },
+        CalculatedColumnSettings: Object.assign(Object.assign({}, defaultSpecialColumnSettings), { DataType: undefined }),
     };
 }
 export function CreateEmptyNamedQuery(expression) {
@@ -245,24 +235,14 @@ export function CreateEmptyFormatColumn() {
         CellAlignment: undefined,
     };
 }
-export function CreateEmptyFreeTextColumn() {
+export function CreateEmptyFreeTextColumn(defaultSpecialColumnSettings) {
     return {
         Uuid: createUuid(),
         ColumnId: EMPTY_STRING,
         DefaultValue: EMPTY_STRING,
         FreeTextStoredValues: [],
         TextEditor: 'Inline',
-        FreeTextColumnSettings: {
-            DataType: 'String',
-            Filterable: false,
-            Resizable: false,
-            Groupable: false,
-            Sortable: false,
-            Pivotable: false,
-            Aggregatable: false,
-            SuppressMenu: false,
-            SuppressMovable: false,
-        },
+        FreeTextColumnSettings: Object.assign(Object.assign({}, defaultSpecialColumnSettings), { DataType: 'String' }),
     };
 }
 export function CreateEmptyLayout(layout, adaptableColumns) {

package/src/Utilities/Services/AggregatedScalarLiveValue.d.ts

@@ -7,6 +7,7 @@ export declare class AggregatedScalarLiveValue {
     private source;
     private requestingModule;
     private adaptableApi;
+    private getRowNodes?;
     private aggregationReducerName;
     private aggregatedScalarExpression;
     private expressionEvaluation;
@@ -15,11 +16,12 @@ export declare class AggregatedScalarLiveValue {
         aggregatedScalarExpression: string;
     }, {
         aggregatedScalarExpressionEvaluation: AggregatedScalarExpressionEvaluation;
-    }>, requestingModule: ModuleConstants, adaptableApi: AdaptableApi);
+    }>, requestingModule: ModuleConstants, adaptableApi: AdaptableApi, getRowNodes?: () => IRowNode[]);
     refresh(): void;
     getAggregatedValueForRow(rowNode: IRowNode): any;
     getAllAggregationValues(): number[];
     private getAggregationValue;
-    private getGlobalAggregatedValue;
+    getGlobalAggregatedValue(): any;
+    private getRowNodeValueForColumnId;
     private computeAggregatedValue;
 }

package/src/Utilities/Services/AggregatedScalarLiveValue.js

@@ -8,18 +8,18 @@ const logOnce = (message, loggingFn) => {
     doOnceFlags[message] = true;
 };
 export class AggregatedScalarLiveValue {
-    constructor(source, requestingModule, adaptableApi) {
+    constructor(source, requestingModule, adaptableApi, getRowNodes) {
         this.source = source;
         this.requestingModule = requestingModule;
         this.adaptableApi = adaptableApi;
+        this.getRowNodes = getRowNodes;
         if (source.aggregatedScalarExpression) {
             this.aggregatedScalarExpression = source.aggregatedScalarExpression;
         }
         this.expressionEvaluation = source.aggregatedScalarExpression
             ? this.adaptableApi.internalApi
                 .getQueryLanguageService()
-                .evaluateAggregatedScalarExpression(source.aggregatedScalarExpression, requestingModule)
-                .value
+                .evaluateAggregatedScalarExpression(source.aggregatedScalarExpression, requestingModule, getRowNodes).value
             : source.aggregatedScalarExpressionEvaluation;
         // currently we support only one reducer
         this.aggregationReducerName = Object.keys(this.expressionEvaluation.aggregationParams.reducers)[0];
@@ -29,7 +29,7 @@ export class AggregatedScalarLiveValue {
         if (this.aggregatedScalarExpression) {
             this.expressionEvaluation = this.adaptableApi.internalApi
                 .getQueryLanguageService()
-                .evaluateAggregatedScalarExpression(this.aggregatedScalarExpression, this.requestingModule).value;
+                .evaluateAggregatedScalarExpression(this.aggregatedScalarExpression, this.requestingModule, this.getRowNodes).value;
         }
         // currently we support only one reducer
         this.aggregationReducerName = Object.keys(this.expressionEvaluation.aggregationParams.reducers)[0];
@@ -38,7 +38,9 @@ export class AggregatedScalarLiveValue {
     getAggregatedValueForRow(rowNode) {
         const aggregationValue = this.getAggregationValue(rowNode);
         if (aggregationValue == undefined) {
-            logOnce(`${this.aggregatedScalarExpression} :: aggregation value is NOT available!`, this.adaptableApi.logWarn);
+            logOnce(`${this.aggregatedScalarExpression} :: aggregation value is NOT available!`, (message) => {
+                this.adaptableApi.internalApi.getAdaptableInstance().logger.warn(message);
+            });
             return;
         }
         if (this.expressionEvaluation.rowValueGetter) {
@@ -58,7 +60,7 @@ export class AggregatedScalarLiveValue {
         var _a, _b;
         if ((_a = this.expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
             const groupColumns = this.expressionEvaluation.aggregationParams.groupBy.map((groupByParam) => groupByParam.field);
-            const groupKeys = groupColumns.map((groupColumnName) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, groupColumnName));
+            const groupKeys = groupColumns.map((groupColumnName) => this.getRowNodeValueForColumnId(rowNode, groupColumnName));
             return (_b = this.aggregationResult.deepMap.get(groupKeys)) === null || _b === void 0 ? void 0 : _b.reducerResults[this.aggregationReducerName];
         }
         return this.getGlobalAggregatedValue();
@@ -66,25 +68,30 @@ export class AggregatedScalarLiveValue {
     getGlobalAggregatedValue() {
         return this.aggregationResult.reducerResults[this.aggregationReducerName];
     }
+    getRowNodeValueForColumnId(rowNode, columnId) {
+        const rawValue = this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, columnId);
+        // we need to convert the Date object to a number, otherwise the grouping will not work (each Date instance is unique)
+        return rawValue instanceof Date ? rawValue.getTime() : rawValue;
+    }
     computeAggregatedValue(expressionEvaluation) {
         var _a;
-        const gridRowNodes = this.adaptableApi.gridApi.getAllRowNodes({
-            filterFn: expressionEvaluation.rowFilterFn,
-        });
+        const gridRowNodes = expressionEvaluation.getRowNodes
+            ? expressionEvaluation.getRowNodes()
+            : this.adaptableApi.gridApi.getAllRowNodes({
+                filterFn: expressionEvaluation.rowFilterFn,
+            });
         // we iterate over the RowNode list (we need this to handle complex column values (nested values, valueGetters etc)
         // so we will map the fieldNames to RowNode.data
-        const mapReducerValueGetter = (fieldName) => {
-            return (rowNode) => {
-                return this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, fieldName);
-            };
+        const mapReducerValueGetter = (columnId) => {
+            return (rowNode) => this.getRowNodeValueForColumnId(rowNode, columnId);
         };
         Object.values(expressionEvaluation.aggregationParams.reducers).forEach((aggregationReducer) => {
             aggregationReducer.getter = mapReducerValueGetter(aggregationReducer.field);
             // nullify the field to force the fallback on the getter fn
             aggregationReducer.field = null;
         });
-        const mapGroupByToKey = (fieldName) => {
-            return (_unusableProperty, rowNode) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, fieldName);
+        const mapGroupByToKey = (columnId) => {
+            return (_unusableProperty, rowNode) => this.getRowNodeValueForColumnId(rowNode, columnId);
         };
         (_a = expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.forEach((groupByDef) => {
             groupByDef.toKey = mapGroupByToKey(groupByDef.field);
@@ -92,11 +99,10 @@ export class AggregatedScalarLiveValue {
         let aggregatedRowNodes = gridRowNodes;
         if (expressionEvaluation.sortByColumn) {
             const sortByColumn = expressionEvaluation.sortByColumn;
-            const getRowNodeValue = (rowNode, columnId) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, columnId);
             // currently, we support only ascending sorting
             aggregatedRowNodes.sort((first, second) => {
-                const firstValue = getRowNodeValue(first, sortByColumn);
-                const secondValue = getRowNodeValue(second, sortByColumn);
+                const firstValue = this.getRowNodeValueForColumnId(first, sortByColumn);
+                const secondValue = this.getRowNodeValueForColumnId(second, sortByColumn);
                 if (firstValue < secondValue) {
                     return -1;
                 }
@@ -106,6 +112,7 @@ export class AggregatedScalarLiveValue {
                 return 0;
             });
         }
-        return aggregate(expressionEvaluation.aggregationParams, aggregatedRowNodes);
+        const result = aggregate(expressionEvaluation.aggregationParams, aggregatedRowNodes);
+        return result;
     }
 }

package/src/Utilities/Services/CellPopupService.js

@@ -6,7 +6,6 @@ export class CellPopupService {
     constructor(api) {
         this.api = api;
         this.adaptable = api.internalApi.getAdaptableInstance();
-        this.adaptable = api.internalApi.getAdaptableInstance();
         this.adaptable.api.eventApi.on('AdaptableReady', () => this.handleAdaptableReady());
     }
     getAdaptableState() {
@@ -75,7 +74,7 @@ export class CellPopupService {
             this.hidePopup();
             return;
         }
-        const cellNotes = this.adaptable.api.notesApi.getCellNotes(cellPosition);
+        const cellNotes = this.adaptable.api.noteApi.getNotesForCell(cellPosition);
         const cellComments = this.adaptable.api.commentApi.getCommentThread(cellPosition);
         const hasNotesOrComments = (cellNotes === null || cellNotes === void 0 ? void 0 : cellNotes.length) || cellComments;
         // call only if it is different
@@ -93,7 +92,7 @@ export class CellPopupService {
             return;
         }
         // if open but this has no note, close
-        const cellNotes = this.adaptable.api.notesApi.getCellNotes(cellAddress);
+        const cellNotes = this.adaptable.api.noteApi.getNotesForCell(cellAddress);
         const cellComments = this.adaptable.api.commentApi.getCommentThread(cellAddress);
         const hasNotesOrComments = (cellNotes === null || cellNotes === void 0 ? void 0 : cellNotes.length) || cellComments;
         if (openCellAddress && !hasNotesOrComments) {

package/src/Utilities/Services/Interface/IQueryLanguageService.d.ts

@@ -15,7 +15,7 @@ export interface IQueryLanguageService extends IAdaptableService {
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
     evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo | GridDataChangedInfo>;
     evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): BooleanAggregationParameter;
-    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): ScalarAggregationParameter;
+    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule, getRowNodes?: () => IRowNode[]): ScalarAggregationParameter;
     validateBoolean(expression: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {

package/src/Utilities/Services/Interface/IReportService.d.ts

@@ -4,11 +4,8 @@ import { IAdaptableService } from './IAdaptableService';
 import { ExcelStyle, IRowNode } from '@ag-grid-community/core';
 import { CustomDestination, SystemExportDestination } from '../../../types';
 export interface IReportService extends IAdaptableService {
-    resetExcelStyleMemoization(): void;
-    registerExcelStyle(excelStyle: Partial<ExcelStyle>, cellClassKey: string): void;
-    getRegisteredExcelStyles(): ExcelStyle[];
+    buildExcelStylesForVisualReports(): ExcelStyle[];
     getExcelStyleIdForCellClassKey(cellClassKey: string): string;
-    registerExcelStyleWithFormattedDate(cellClassId: string, isoFormattedValue: string): void;
     getExcelStyleWithFormattedDate(cellClassId: string): string;
     CreateSystemReport(systemReportName: SystemReportName): Report;
     IsSystemReport(reportName: string): boolean;

package/src/Utilities/Services/LicenseService/index.d.ts

@@ -13,9 +13,12 @@ export declare enum LicenseValidityType {
 }
 export declare class LicenseService implements ILicenseService {
     private adaptable;
+    private licenseKey;
+    private packageDetails;
     constructor(adaptable: IAdaptable, licenseKey: string | undefined, packageDetails: {
         publishedAt: number | Date;
     });
+    init(): void;
     getValidityType(details: LicenseDetails | Error | null, packageDetails: {
         publishedAt: number | Date;
     }): LicenseValidityType;