@adaptabletools/adaptable-cjs 18.0.0-canary.9 → 18.0.1

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aggregatedScalarExpressionFunctionNames = exports.aggregatedScalarExpressionFunctions = exports.quantileAggregatedExpressionFunctions = exports.cumulativeAggregatedExpressionFunctions = exports.aggregatedExpressionFunctions = void 0;
-const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+const tslib_1 = require("tslib");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
-const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 const ArrayExtensions_1 = require("../Extensions/ArrayExtensions");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
+const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+const isAfter_1 = tslib_1.__importDefault(require("date-fns/isAfter"));
+const DateHelper_1 = require("../Helpers/DateHelper");
 exports.aggregatedExpressionFunctions = [
     'SUM',
     'PERCENTAGE',
@@ -116,6 +119,7 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['SUM([colA])', 'SUM([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
     },
     PERCENTAGE: {
         handler(args, context) {
@@ -259,6 +263,7 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['AVG([colA])', 'AVG([colA], GROUP_BY([colB]))', 'AVG([colA], WEIGHT([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
     },
     MEDIAN: {
         handler(args, context) {
@@ -323,12 +328,13 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['MEDIAN([colA])', 'MEDIAN([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
     },
     MODE: {
         handler(args, context) {
             const modeColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('mode', args);
             const modeColumnName = modeColumnParameter.value;
-            (0, expressionFunctionUtils_1.validateColumnType)(modeColumnName, ['Number'], 'mode', context.adaptableApi);
+            (0, expressionFunctionUtils_1.validateColumnType)(modeColumnName, ['Number', 'String', 'Date'], 'mode', context.adaptableApi);
             const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('MODE', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -342,12 +348,16 @@ exports.aggregatedScalarExpressionFunctions = {
                             reducer: (aggregatedValue, rowValue, rowNode) => {
                                 var _a;
                                 if (typeof rowValue !== 'number' && typeof rowValue !== 'string') {
-                                    return;
+                                    return aggregatedValue;
+                                }
+                                if (!aggregatedValue) {
+                                    return new Map();
                                 }
                                 aggregatedValue.set(rowValue, ((_a = aggregatedValue.get(rowValue)) !== null && _a !== void 0 ? _a : 0) + 1);
                                 return aggregatedValue;
                             },
                             done: (aggregatedValue) => {
+                                var _a;
                                 const sorted = [...aggregatedValue.entries()].sort(([aVal, aFreq], [bVal, bFreq]) => {
                                     if (aFreq < bFreq) {
                                         return 1;
@@ -359,7 +369,7 @@ exports.aggregatedScalarExpressionFunctions = {
                                         return aVal === bVal ? 0 : 1;
                                     }
                                 });
-                                return sorted[0][0];
+                                return (_a = sorted === null || sorted === void 0 ? void 0 : sorted[0]) === null || _a === void 0 ? void 0 : _a[0];
                             },
                         },
                     },
@@ -384,6 +394,7 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['MODE([colA])', 'MODE([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: [['number'], ['text'], ['date']],
     },
     DISTINCT: {
         handler(args, context) {
@@ -431,6 +442,7 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['DISTINCT([colA])', 'DISTINCT([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: [['number'], ['text'], ['date']],
     },
     ONLY: {
         handler(args, context) {
@@ -480,6 +492,7 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['ONLY([colA])', 'ONLY([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: [['number'], ['text'], ['date']],
     },
     STD_DEVIATION: {
         handler(args, context) {
@@ -537,6 +550,7 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['ONLY([colA])', 'ONLY([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
     },
     MIN: {
         handler(args, context) {
@@ -588,6 +602,7 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
     },
     MAX: {
         handler(args, context) {
@@ -639,6 +654,7 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: ['number'],
     },
     QUANT: {
         handler(args, context) {
@@ -837,6 +853,7 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['COUNT([colA])', 'COUNT([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
+        inputs: [['number'], ['text'], ['date']],
     },
     OVER: {
         handler(args, context) {
@@ -898,6 +915,124 @@ exports.aggregatedScalarExpressionFunctions = {
         examples: ['[col1]', 'COL("col1")'],
         category: 'special',
     },
+    OLDEST: {
+        handler(args, context) {
+            const minColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('OLDEST', args);
+            const minColumnName = minColumnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(minColumnName, ['Date'], 'OLDEST', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('OLDEST', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        OLDEST: {
+                            name: 'OLDEST',
+                            field: minColumnName,
+                            initialValue: null,
+                            reducer: (minValue, rowValue) => {
+                                if (!minValue) {
+                                    return rowValue;
+                                }
+                                if (!rowValue) {
+                                    return minValue;
+                                }
+                                if ((0, isAfter_1.default)((0, DateHelper_1.parseDateValue)(minValue), (0, DateHelper_1.parseDateValue)(rowValue))) {
+                                    return rowValue;
+                                }
+                                else {
+                                    return minValue;
+                                }
+                            },
+                            done: (minValue, arr) => {
+                                if (minValue !== null) {
+                                    return minValue;
+                                }
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'OLDEST',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a Date column over multiple rows by computing the oldest of the column values\nOptionally the aggregation may be computed within provided individual groups',
+        signatures: [
+            'OLDEST( [colName] )',
+            'OLDEST( COL(name: string))',
+            'OLDEST( [colNameA], GROUP_BY( [colNameB] ))',
+            'OLDEST( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['OLDEST([colA])', 'OLDEST([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+        inputs: ['date'],
+    },
+    NEWEST: {
+        handler(args, context) {
+            const minColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('NEWEST', args);
+            const minColumnName = minColumnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(minColumnName, ['Date'], 'NEWEST', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('NEWEST', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        NEWEST: {
+                            name: 'NEWEST',
+                            field: minColumnName,
+                            initialValue: null,
+                            reducer: (minValue, rowValue) => {
+                                if (!minValue) {
+                                    return rowValue;
+                                }
+                                if (!rowValue) {
+                                    return minValue;
+                                }
+                                if ((0, isAfter_1.default)((0, DateHelper_1.parseDateValue)(minValue), (0, DateHelper_1.parseDateValue)(rowValue))) {
+                                    return minValue;
+                                }
+                                else {
+                                    return rowValue;
+                                }
+                            },
+                            done: (minValue, arr) => {
+                                if (minValue !== null) {
+                                    return minValue;
+                                }
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'NEWEST',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a Date column over multiple rows by computing the most recent of the column values\nOptionally the aggregation may be computed within provided individual groups',
+        signatures: [
+            'NEWEST( [colName] )',
+            'NEWEST( COL(name: string))',
+            'NEWEST( [colNameA], GROUP_BY( [colNameB] ))',
+            'NEWEST( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['NEWEST([colA])', 'NEWEST([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+        inputs: ['date'],
+    },
 };
 const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, context) => {
     const aggregationEvaluation = aggregationParameter.value;
@@ -969,13 +1104,15 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
                                 if ((_a = aggregationEvaluation.context) === null || _a === void 0 ? void 0 : _a.weightParam) {
                                     // weighted average
                                     const weightValue = (_b = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, aggregationEvaluation.context.weightParam.value)) !== null && _b !== void 0 ? _b : 0;
-                                    cumulationBag.currentValue = cumulationBag.currentValue + rowValue * weightValue;
+                                    cumulationBag.currentValue =
+                                        cumulationBag.currentValue + rowValue * weightValue;
                                     cumulationBag.numberOfCumulatedValues =
                                         cumulationBag.numberOfCumulatedValues + weightValue;
                                 }
                                 else {
                                     cumulationBag.currentValue = cumulationBag.currentValue + rowValue;
-                                    cumulationBag.numberOfCumulatedValues = cumulationBag.numberOfCumulatedValues + 1;
+                                    cumulationBag.numberOfCumulatedValues =
+                                        cumulationBag.numberOfCumulatedValues + 1;
                                 }
                             }
                             if (cumulationBag.numberOfCumulatedValues !== 0) {

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -279,10 +279,10 @@ const isLastElementMinValue = (values) => {
 };
 // useful for functions which do NOT have an initial change (ex. GRID_CHANGE NONE)
 const getDataChangedInfoStub = (context) => {
-    var _a;
+    var _a, _b;
     let rowNodeStub;
     if (!context.filterFn) {
-        rowNodeStub = context.adaptableApi.gridApi.getFirstRowNode();
+        rowNodeStub = (_a = context.node) !== null && _a !== void 0 ? _a : context.adaptableApi.gridApi.getFirstRowNode();
     }
     else {
         // if there is a WHERE clause defined, find the first rowNode which satisfies the condition
@@ -297,7 +297,7 @@ const getDataChangedInfoStub = (context) => {
     const rowNode = rowNodeStub;
     if (rowNode) {
         const primaryKeyValue = context.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(rowNode);
-        const columnId = (_a = context.adaptableApi.columnApi.getQueryableColumns()[0]) === null || _a === void 0 ? void 0 : _a.columnId;
+        const columnId = (_b = context.adaptableApi.columnApi.getQueryableColumns()[0]) === null || _b === void 0 ? void 0 : _b.columnId;
         const oldValue = context.adaptableApi.gridApi.getCellRawValue(primaryKeyValue, columnId);
         const column = context.adaptableApi.columnApi.getColumnWithColumnId(columnId);
         const newValue = oldValue;

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

@@ -2,6 +2,6 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Scalar Functions available in AdaptableQL
  */
-export type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'ABS' | 'CEILING' | 'FLOOR' | 'ROUND' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'CURRENT_DAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'NULL' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'CASE' | 'COL' | 'VAR' | 'TO_ARRAY' | 'QUERY' | 'IS_BLANK' | 'IS_NOT_BLANK';
+export type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'ABS' | 'CEILING' | 'FLOOR' | 'ROUND' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'CURRENT_DAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'NULL' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'CASE' | 'COL' | 'FIELD' | 'VAR' | 'TO_ARRAY' | 'QUERY' | 'IS_BLANK' | 'IS_NOT_BLANK';
 export declare const scalarExpressionFunctions: Record<ScalarFunctionName, ExpressionFunction>;
 export declare const scalarExpressionFunctionNames: ScalarFunctionName[];

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -72,6 +72,21 @@ exports.scalarExpressionFunctions = {
         category: 'special',
         returnType: 'any',
     },
+    FIELD: {
+        handler(args, context) {
+            var _a, _b;
+            const fieldName = args[0];
+            if (StringExtensions_1.default.IsNullOrEmpty(fieldName)) {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('FIELD', 'requires a field name');
+            }
+            return (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.internalApi.getValueUsingField((_b = context.node) === null || _b === void 0 ? void 0 : _b.data, fieldName);
+        },
+        description: 'Returns the value of a row field (not necessarily mapped to a column). If the field is nested, use dot notation (e.g. "nested.fieldName")',
+        signatures: ['FIELD(fieldName:string)'],
+        examples: ['FIELD("fieldName")', 'FIELD("nested.fieldName")'],
+        category: 'special',
+        returnType: 'any',
+    },
     QUERY: {
         handler(args, context) {
             var _a, _b;

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

@@ -8,7 +8,8 @@ export declare function checkValidPrimaryKey(adaptable: IAdaptable): boolean;
 export declare function AdaptableObjectExistsInState(array: AdaptableObject[], itemToCheck: AdaptableObject): boolean;
 export declare function getAppropriateAccessLevel(adaptableObject: AdaptableObject, moduleAccessLevel: AccessLevel): AccessLevel;
 export declare function runAdaptableComparerFunction(columnId: string, columnValues: any[], adaptable: IAdaptable): AdaptableComparerFunction;
-export declare function addUuidAndSource(adaptableObject: AdaptableObject): AdaptableObject;
+export declare function addUuidAndSource<T extends AdaptableObject>(adaptableObject: T): T;
+export declare function removeUuidAndSource<T extends AdaptableObject>(adaptableObject: T): T;
 export declare const AdaptableHelper: {
     initPredefinedConfigWithUuids: typeof initPredefinedConfigWithUuids;
     checkValidPrimaryKey: typeof checkValidPrimaryKey;
@@ -16,5 +17,6 @@ export declare const AdaptableHelper: {
     runAdaptableComparerFunction: typeof runAdaptableComparerFunction;
     getAppropriateAccessLevel: typeof getAppropriateAccessLevel;
     addUuidAndSource: typeof addUuidAndSource;
+    removeUuidAndSource: typeof removeUuidAndSource;
 };
 export default AdaptableHelper;

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptableHelper = exports.addUuidAndSource = exports.runAdaptableComparerFunction = exports.getAppropriateAccessLevel = exports.AdaptableObjectExistsInState = exports.checkValidPrimaryKey = exports.initPredefinedConfigWithUuids = void 0;
+exports.AdaptableHelper = exports.removeUuidAndSource = exports.addUuidAndSource = exports.runAdaptableComparerFunction = exports.getAppropriateAccessLevel = exports.AdaptableObjectExistsInState = exports.checkValidPrimaryKey = exports.initPredefinedConfigWithUuids = void 0;
 const tslib_1 = require("tslib");
 const cloneDeepWith_1 = tslib_1.__importDefault(require("lodash/cloneDeepWith"));
 const isPlainObject_1 = tslib_1.__importDefault(require("lodash/isPlainObject"));
@@ -96,6 +96,25 @@ function addUuidAndSource(adaptableObject) {
     return adaptableObject;
 }
 exports.addUuidAndSource = addUuidAndSource;
+function removeUuidAndSource(adaptableObject) {
+    const clonedObject = structuredClone(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(clonedObject);
+    return clonedObject;
+}
+exports.removeUuidAndSource = removeUuidAndSource;
 exports.AdaptableHelper = {
     initPredefinedConfigWithUuids,
     checkValidPrimaryKey,
@@ -103,5 +122,6 @@ exports.AdaptableHelper = {
     runAdaptableComparerFunction,
     getAppropriateAccessLevel,
     addUuidAndSource,
+    removeUuidAndSource,
 };
 exports.default = exports.AdaptableHelper;

package/src/Utilities/Interface/MessagePopups.d.ts

@@ -32,9 +32,6 @@ export interface ScreenPopup {
         [key: string]: any;
     };
 }
-export interface LoadingPopup {
-    ShowLoadingPopup: boolean;
-}
 export interface ConfirmationPopup {
     ShowConfirmationPopup: boolean;
     Header: string;

package/src/Utilities/MenuItem.d.ts

@@ -1,26 +1,29 @@
 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);
+export declare class MenuItemDoReduxAction<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName> implements AdaptableMenuItem<MENU_TYPE_NAME> {
+    constructor(name: MENU_TYPE_NAME, label: string, module: AdaptableModule, reduxAction: Redux.Action, icon: AdaptableSystemIconName, isVisible: boolean);
+    name: MENU_TYPE_NAME;
     reduxAction: Redux.Action;
     label: string;
     module: AdaptableModule;
     isVisible: boolean;
     icon: AdaptableIcon;
 }
-export declare class MenuItemDoClickFunction implements AdaptableMenuItem {
-    constructor(label: string, module: AdaptableModule, clickFunction: () => void, icon: AdaptableSystemIconName, isVisible: boolean);
+export declare class MenuItemDoClickFunction<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName> implements AdaptableMenuItem<MENU_TYPE_NAME> {
+    constructor(name: MENU_TYPE_NAME, label: string, module: AdaptableModule, clickFunction: () => void, icon: AdaptableSystemIconName, isVisible: boolean);
+    name: MENU_TYPE_NAME;
     onClick: () => void;
     label: string;
     module: AdaptableModule;
     isVisible: boolean;
     icon: AdaptableIcon;
 }
-export declare class MenuItemShowPopup implements AdaptableMenuItem {
-    constructor(label: string, module: AdaptableModule, componentName: string, icon: AdaptableSystemIconName, isVisible: boolean, popupParams?: ModuleParams);
+export declare class MenuItemShowPopup<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName> implements AdaptableMenuItem<MENU_TYPE_NAME> {
+    constructor(name: MENU_TYPE_NAME, label: string, module: AdaptableModule, componentName: string, icon: AdaptableSystemIconName, isVisible: boolean, popupParams?: ModuleParams);
+    name: MENU_TYPE_NAME;
     reduxAction: Redux.Action;
     label: string;
     module: AdaptableModule;

package/src/Utilities/MenuItem.js

@@ -5,7 +5,8 @@ const tslib_1 = require("tslib");
 const PopupRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/PopupRedux"));
 // A menu item which performs a Redux Action when it is clicke
 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;
@@ -17,7 +18,8 @@ class MenuItemDoReduxAction {
 }
 exports.MenuItemDoReduxAction = MenuItemDoReduxAction;
 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;
@@ -30,7 +32,8 @@ class MenuItemDoClickFunction {
 exports.MenuItemDoClickFunction = MenuItemDoClickFunction;
 // A menu item which shows a popup screen when it is clieked
 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

@@ -23,7 +23,7 @@ function CreateAdaptableComment(text, api) {
     return comment;
 }
 exports.CreateAdaptableComment = CreateAdaptableComment;
-function CreateEmptyCalculatedColumn() {
+function CreateEmptyCalculatedColumn(defaultSpecialColumnSettings) {
     return {
         Uuid: (0, Uuid_1.createUuid)(),
         ColumnId: GeneralConstants_1.EMPTY_STRING,
@@ -31,17 +31,7 @@ function CreateEmptyCalculatedColumn() {
             ScalarExpression: GeneralConstants_1.EMPTY_STRING,
         },
         // need to create some defaults - which we will change later
-        CalculatedColumnSettings: {
-            DataType: undefined,
-            Filterable: true,
-            Resizable: true,
-            Groupable: false,
-            Sortable: true,
-            Pivotable: false,
-            Aggregatable: false,
-            SuppressMenu: false,
-            SuppressMovable: false,
-        },
+        CalculatedColumnSettings: Object.assign(Object.assign({}, defaultSpecialColumnSettings), { DataType: undefined }),
     };
 }
 exports.CreateEmptyCalculatedColumn = CreateEmptyCalculatedColumn;
@@ -270,27 +260,18 @@ function CreateEmptyFormatColumn() {
         Style: CreateEmptyStyle(),
         DisplayFormat: undefined,
         CellAlignment: undefined,
+        RowScope: undefined,
     };
 }
 exports.CreateEmptyFormatColumn = CreateEmptyFormatColumn;
-function CreateEmptyFreeTextColumn() {
+function CreateEmptyFreeTextColumn(defaultSpecialColumnSettings) {
     return {
         Uuid: (0, Uuid_1.createUuid)(),
         ColumnId: GeneralConstants_1.EMPTY_STRING,
         DefaultValue: GeneralConstants_1.EMPTY_STRING,
         FreeTextStoredValues: [],
         TextEditor: 'Inline',
-        FreeTextColumnSettings: {
-            DataType: 'String',
-            Filterable: true,
-            Resizable: true,
-            Groupable: false,
-            Sortable: true,
-            Pivotable: false,
-            Aggregatable: false,
-            SuppressMenu: false,
-            SuppressMovable: false,
-        },
+        FreeTextColumnSettings: Object.assign(Object.assign({}, defaultSpecialColumnSettings), { DataType: 'String' }),
     };
 }
 exports.CreateEmptyFreeTextColumn = CreateEmptyFreeTextColumn;
@@ -333,6 +314,8 @@ function CreateEmptyCellSummmary() {
         Max: undefined,
         Min: undefined,
         Count: undefined,
+        Newest: undefined,
+        Oldest: undefined,
         Std_Deviation: undefined,
         Only: undefined,
     };
@@ -352,7 +335,6 @@ function CreateEmptyStyledColumn() {
     return {
         Uuid: (0, Uuid_1.createUuid)(),
         ColumnId: GeneralConstants_1.EMPTY_STRING,
-        IncludeGroupedRows: false,
     };
 }
 exports.CreateEmptyStyledColumn = CreateEmptyStyledColumn;

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

@@ -22,5 +22,6 @@ export declare class AggregatedScalarLiveValue {
     getAllAggregationValues(): number[];
     private getAggregationValue;
     getGlobalAggregatedValue(): any;
+    private getRowNodeValueForColumnId;
     private computeAggregatedValue;
 }

package/src/Utilities/Services/AggregatedScalarLiveValue.js

@@ -63,7 +63,7 @@ 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();
@@ -71,6 +71,11 @@ 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 = expressionEvaluation.getRowNodes
@@ -80,18 +85,16 @@ class AggregatedScalarLiveValue {
             });
         // 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);
@@ -99,11 +102,10 @@ 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;
                 }