@adaptabletools/adaptable 18.0.6 → 18.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "18.0.6",
+  "version": "18.0.7",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/src/Api/Implementation/DataImportApiImpl.js

@@ -5,6 +5,8 @@ export class DataImportApiImpl extends ApiBase {
         super(adaptable);
         this.internalApi = new DataImportInternalApi(adaptable);
     }
-    openImportWizard() { }
+    openImportWizard() {
+        this.getSettingsPanelApi().openSettingsPanel('DataImport');
+    }
     importData(partialRows) { }
 }

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

@@ -15,8 +15,6 @@ export interface CellSummmary {
     Count: number | undefined;
     Only: string | undefined;
     Std_Deviation: number | undefined;
-    Oldest: Date | undefined;
-    Newest: Date | undefined;
     [key: string]: any;
 }
 /**

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

@@ -59,8 +59,6 @@ export declare enum SummaryOperation {
     Max = "Max",
     Min = "Min",
     Count = "Count",
-    Newest = "Newest",
-    Oldest = "Oldest",
     Std_Deviation = "Std Deviation",
     Only = "Only",
     Weighted_Average = "Weighted Avg"

package/src/PredefinedConfig/Common/Enums.js

@@ -73,8 +73,6 @@ export var SummaryOperation;
     SummaryOperation["Max"] = "Max";
     SummaryOperation["Min"] = "Min";
     SummaryOperation["Count"] = "Count";
-    SummaryOperation["Newest"] = "Newest";
-    SummaryOperation["Oldest"] = "Oldest";
     SummaryOperation["Std_Deviation"] = "Std Deviation";
     SummaryOperation["Only"] = "Only";
     SummaryOperation["Weighted_Average"] = "Weighted Avg";

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

@@ -1,6 +1,6 @@
 export declare const ROW_SUMMARY_ROW_ID = "__ROW_SUMMARY_ROW_ID";
 export declare const WEIGHTED_AVERAGE_AGGREATED_FUNCTION = "WEIGHTED_AVERAGE";
-export declare const summarySupportedExpressions: readonly ["MIN", "MAX", "SUM", "AVG", "COUNT", "MEDIAN", "MODE", "DISTINCT", "ONLY", "OLDEST", "NEWEST", "STD_DEVIATION", "WEIGHTED_AVERAGE"];
+export declare const summarySupportedExpressions: readonly ["MIN", "MAX", "SUM", "AVG", "COUNT", "MEDIAN", "MODE", "DISTINCT", "ONLY", "STD_DEVIATION", "WEIGHTED_AVERAGE"];
 export type SummarySupportedExpression = (typeof summarySupportedExpressions)[number];
 /**
  * Position of Row Summary - 'Top' or 'Bottom'

package/src/PredefinedConfig/Common/RowSummary.js

@@ -10,8 +10,6 @@ export const summarySupportedExpressions = [
     'MODE',
     'DISTINCT',
     'ONLY',
-    'OLDEST',
-    'NEWEST',
     'STD_DEVIATION',
     WEIGHTED_AVERAGE_AGGREATED_FUNCTION,
 ];

package/src/Strategy/CellSummaryModule.js

@@ -74,10 +74,8 @@ export class CellSummaryModule extends AdaptableModuleBase {
                 const modeValue = isNumericColumn ? handleExpression('MODE') : null;
                 const medianValue = isNumericColumn ? handleExpression('MEDIAN') : null;
                 const distinctValue = handleExpression('DISTINCT');
-                const maxValue = isNumericColumn ? handleExpression('MAX') : null;
-                const minValue = isNumericColumn ? handleExpression('MIN') : null;
-                const oldestValue = isDateColumn ? handleExpression('OLDEST') : null;
-                const newestValue = isDateColumn ? handleExpression('NEWEST') : null;
+                const maxValue = isNumericColumn || isDateColumn ? handleExpression('MAX') : null;
+                const minValue = isNumericColumn || isDateColumn ? handleExpression('MIN') : null;
                 const stdDeviation = isNumericColumn
                     ? Helper.roundNumberTo4dp(handleExpression('STD_DEVIATION'))
                     : null;
@@ -90,8 +88,6 @@ export class CellSummaryModule extends AdaptableModuleBase {
                     Max: maxValue,
                     Min: minValue,
                     Count: selectedCellInfo.gridCells.length,
-                    Oldest: oldestValue,
-                    Newest: newestValue,
                     Std_Deviation: stdDeviation,
                     Only: distinctValue == 1 ? JSON.stringify(selectedCellInfo.gridCells[0].rawValue) : '',
                 };

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

@@ -2,11 +2,12 @@ import { IRowNode } from '@ag-grid-community/core';
 import { ExpressionFunction } from '../../parser/src/types';
 import { BaseParameter } from './expressionFunctionUtils';
 import { AggregateParams } from './scalarAggregationHelper';
+import { AdaptableColumnDataType } from '../../types';
 /**
  * List of all the AggregatedScalar Functions available in AdaptableQL
  */
 export type AggregatedScalarFunctionName = ScalarAggregationFunction | OperandFunction;
-export type ScalarAggregationFunction = 'SUM' | 'PERCENTAGE' | 'QUANT' | 'QUARTILE' | 'PERCENTILE' | 'AVG' | 'MIN' | 'MAX' | 'COUNT' | 'CUMUL' | 'MEDIAN' | 'MODE' | 'DISTINCT' | 'ONLY' | 'STD_DEVIATION' | 'OLDEST' | 'NEWEST';
+export type ScalarAggregationFunction = 'SUM' | 'PERCENTAGE' | 'QUANT' | 'QUARTILE' | 'PERCENTILE' | 'AVG' | 'MIN' | 'MAX' | 'COUNT' | 'CUMUL' | 'MEDIAN' | 'MODE' | 'DISTINCT' | 'ONLY' | 'STD_DEVIATION';
 type OperandFunction = 'COL' | 'OVER' | 'GROUP_BY' | 'WEIGHT';
 export interface ScalarAggregationParameter extends BaseParameter<'aggregationScalar', ScalarAggregationFunction> {
     value: AggregatedScalarExpressionEvaluation;
@@ -29,6 +30,7 @@ export interface AggregatedScalarExpressionEvaluation {
     sortByColumn?: string;
     rowFilterFn?: (rowNode: IRowNode) => boolean;
     getRowNodes?: () => IRowNode[];
+    columnType?: AdaptableColumnDataType;
 }
 export interface CumulatedAggregationValue {
     currentValue: number;

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -19,8 +19,6 @@ export const aggregatedExpressionFunctions = [
     'DISTINCT',
     'ONLY',
     'STD_DEVIATION',
-    // 'OLDEST', Andrei - we should add these 2 but weirdly they currently return a number (I think;.../)
-    // 'NEWEST',
 ];
 export const cumulativeAggregatedExpressionFunctions = [
     'CUMUL',
@@ -46,7 +44,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const aggregationParameter = extractParameter('CUMUL', 'aggregationScalar', ['SUM', 'PERCENTAGE', 'AVG', 'MIN', 'MAX', 'COUNT'], args);
             const overColumnParameter = extractParameter('CUMUL', 'operand', ['OVER'], args);
-            const groupByParameter = extractParameter('MAX', 'operand', ['GROUP_BY'], args, {
+            const groupByParameter = extractParameter(aggregationParameter.name, 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
             if (!!groupByParameter) {
@@ -75,7 +73,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const sumColumnParameter = extractColumnParameter('SUM', args);
             const sumColumnName = sumColumnParameter.value;
-            validateColumnType(sumColumnName, ['Number'], 'SUM', context.adaptableApi);
+            const columnType = validateColumnType(sumColumnName, ['Number'], 'SUM', context.adaptableApi);
             const groupByParameter = extractParameter('SUM', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -99,6 +97,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
+                columnType,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -124,7 +123,7 @@ export const aggregatedScalarExpressionFunctions = {
             var _a;
             const percentageColumnParameter = extractColumnParameter('PERCENTAGE', args);
             const percentageColumnName = percentageColumnParameter.value;
-            validateColumnType(percentageColumnName, ['Number'], 'PERCENTAGE', context.adaptableApi);
+            const columnType = validateColumnType(percentageColumnName, ['Number'], 'PERCENTAGE', context.adaptableApi);
             const sumOperand = extractParameter('PERCENTAGE', 'aggregationScalar', ['SUM'], args, {
                 isOptional: true,
             });
@@ -163,6 +162,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
+                columnType,
             };
             addGroupByParams(groupByColumnNames, aggregationExpressionEvaluation);
             const result = {
@@ -191,7 +191,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const avgColumnParameter = extractColumnParameter('AVG', args);
             const avgColumnName = avgColumnParameter.value;
-            validateColumnType(avgColumnName, ['Number'], 'AVG', context.adaptableApi);
+            const columnType = validateColumnType(avgColumnName, ['Number'], 'AVG', context.adaptableApi);
             const groupByParameter = extractParameter('AVG', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -238,6 +238,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
+                columnType,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             if (weightParameter) {
@@ -267,7 +268,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const medianColumnParameter = extractColumnParameter('MEDIAN', args);
             const medianColumnName = medianColumnParameter.value;
-            validateColumnType(medianColumnName, ['Number'], 'MEDIAN', context.adaptableApi);
+            const columnType = validateColumnType(medianColumnName, ['Number'], 'MEDIAN', context.adaptableApi);
             const groupByParameter = extractParameter('MEDIAN', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -308,6 +309,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
+                columnType,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -332,7 +334,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const modeColumnParameter = extractColumnParameter('mode', args);
             const modeColumnName = modeColumnParameter.value;
-            validateColumnType(modeColumnName, ['Number', 'String', 'Date'], 'mode', context.adaptableApi);
+            const columnType = validateColumnType(modeColumnName, ['Number', 'String', 'Date'], 'mode', context.adaptableApi);
             const groupByParameter = extractParameter('MODE', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -374,6 +376,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
+                columnType,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -446,7 +449,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const distinctColumnParameter = extractColumnParameter('ONLY', args);
             const onlyColumnName = distinctColumnParameter.value;
-            validateColumnType(onlyColumnName, ['Number'], 'ONLY', context.adaptableApi);
+            const columnType = validateColumnType(onlyColumnName, ['Number'], 'ONLY', context.adaptableApi);
             const groupByParameter = extractParameter('ONLY', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -472,6 +475,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
+                columnType,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -496,7 +500,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const columnParameter = extractColumnParameter('STD_DEVIATION', args);
             const columnName = columnParameter.value;
-            validateColumnType(columnName, ['Number'], 'STD_DEVIATION', context.adaptableApi);
+            const columnType = validateColumnType(columnName, ['Number'], 'STD_DEVIATION', context.adaptableApi);
             const groupByParameter = extractParameter('STD_DEVIATION', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -530,6 +534,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
+                columnType,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -554,7 +559,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const minColumnParameter = extractColumnParameter('MIN', args);
             const minColumnName = minColumnParameter.value;
-            validateColumnType(minColumnName, ['Number'], 'MIN', context.adaptableApi);
+            const columnType = validateColumnType(minColumnName, ['Number', 'Date'], 'MIN', context.adaptableApi);
             const groupByParameter = extractParameter('MIN', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -569,8 +574,19 @@ export const aggregatedScalarExpressionFunctions = {
                                 if (isUndefinedValue(rowValue)) {
                                     return minValue;
                                 }
-                                const numericRowValue = getNumericValue(rowValue);
-                                return numericRowValue < minValue ? numericRowValue : minValue;
+                                if (minValue === Number.MAX_VALUE) {
+                                    return rowValue;
+                                }
+                                if (columnType === 'Number') {
+                                    const numericRowValue = getNumericValue(rowValue);
+                                    return numericRowValue < minValue ? numericRowValue : minValue;
+                                }
+                                else {
+                                    // Date
+                                    return isAfter(parseDateValue(rowValue), parseDateValue(minValue))
+                                        ? minValue
+                                        : rowValue;
+                                }
                             },
                             done: (minValue) => {
                                 if (minValue !== Number.MAX_VALUE) {
@@ -582,6 +598,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
+                columnType,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -606,7 +623,7 @@ export const aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const maxColumnParameter = extractColumnParameter('MAX', args);
             const maxColumnName = maxColumnParameter.value;
-            validateColumnType(maxColumnName, ['Number'], 'MAX', context.adaptableApi);
+            const columnType = validateColumnType(maxColumnName, ['Number', 'Date'], 'MAX', context.adaptableApi);
             const groupByParameter = extractParameter('MAX', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
@@ -621,8 +638,19 @@ export const aggregatedScalarExpressionFunctions = {
                                 if (isUndefinedValue(rowValue)) {
                                     return maxValue;
                                 }
-                                const numericRowValue = getNumericValue(rowValue);
-                                return numericRowValue > maxValue ? numericRowValue : maxValue;
+                                if (maxValue === Number.MIN_VALUE) {
+                                    return rowValue;
+                                }
+                                if (columnType === 'Number') {
+                                    const numericRowValue = getNumericValue(rowValue);
+                                    return numericRowValue > maxValue ? numericRowValue : maxValue;
+                                }
+                                else {
+                                    // Date
+                                    return isAfter(parseDateValue(rowValue), parseDateValue(maxValue))
+                                        ? rowValue
+                                        : maxValue;
+                                }
                             },
                             done: (maxValue) => {
                                 if (maxValue !== Number.MIN_VALUE) {
@@ -634,6 +662,7 @@ export const aggregatedScalarExpressionFunctions = {
                 },
                 rowFilterFn: context.filterFn,
                 getRowNodes: context.getRowNodes,
+                columnType,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -650,7 +679,7 @@ export const aggregatedScalarExpressionFunctions = {
             'MAX( [colNameA], GROUP_BY( [colNameB] ))',
             'MAX( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
         ],
-        examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
+        examples: ['MAX([colA])', 'MAX([colA], GROUP_BY([colB]))'],
         category: 'aggregation',
         inputs: ['number'],
     },
@@ -659,7 +688,7 @@ export const aggregatedScalarExpressionFunctions = {
             var _a, _b, _c;
             const quantileColumnParameter = extractColumnParameter('QUANT', args);
             const quantileColumnName = quantileColumnParameter.value;
-            validateColumnType(quantileColumnName, ['Number'], 'QUANT', context.adaptableApi);
+            const columnType = validateColumnType(quantileColumnName, ['Number'], 'QUANT', context.adaptableApi);
             const qNumberCandidates = args.filter((arg) => typeof arg === 'number');
             if (qNumberCandidates.length !== 1) {
                 throw new ExpressionEvaluationError('QUANT', 'expects a single positive numeric argument as q-quantile');
@@ -766,6 +795,7 @@ export const aggregatedScalarExpressionFunctions = {
                     }
                     return rowBucketMap[rowValue];
                 },
+                columnType,
             };
             addGroupByParams(groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value, aggregationExpressionEvaluation);
             const result = {
@@ -913,124 +943,6 @@ export const aggregatedScalarExpressionFunctions = {
         examples: ['[col1]', 'COL("col1")'],
         category: 'special',
     },
-    OLDEST: {
-        handler(args, context) {
-            const minColumnParameter = extractColumnParameter('OLDEST', args);
-            const minColumnName = minColumnParameter.value;
-            validateColumnType(minColumnName, ['Date'], 'OLDEST', context.adaptableApi);
-            const groupByParameter = 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 (isAfter(parseDateValue(minValue), 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 = extractColumnParameter('NEWEST', args);
-            const minColumnName = minColumnParameter.value;
-            validateColumnType(minColumnName, ['Date'], 'NEWEST', context.adaptableApi);
-            const groupByParameter = 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 (isAfter(parseDateValue(minValue), 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;
@@ -1060,8 +972,16 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
                     cumulatedValues: {},
                 },
                 reducer: (cumulationBag, rowValue, rowNode) => {
-                    if (isDefinedValue(rowValue) && rowValue < cumulationBag.currentValue) {
-                        cumulationBag.currentValue = rowValue;
+                    if (isDefinedValue(rowValue)) {
+                        if (aggregationEvaluation.columnType === 'Date') {
+                            if (cumulationBag.currentValue === aggregationReducer.initialValue ||
+                                isAfter(parseDateValue(cumulationBag.currentValue), parseDateValue(rowValue))) {
+                                cumulationBag.currentValue = rowValue;
+                            }
+                        }
+                        else if (rowValue < cumulationBag.currentValue) {
+                            cumulationBag.currentValue = rowValue;
+                        }
                     }
                     if (cumulationBag.currentValue !== aggregationReducer.initialValue) {
                         cumulationBag.cumulatedValues[rowNode.id] = cumulationBag.currentValue;
@@ -1078,8 +998,16 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
                         cumulatedValues: {},
                     },
                     reducer: (cumulationBag, rowValue, rowNode) => {
-                        if (isDefinedValue(rowValue) && rowValue > cumulationBag.currentValue) {
-                            cumulationBag.currentValue = rowValue;
+                        if (isDefinedValue(rowValue)) {
+                            if (aggregationEvaluation.columnType === 'Date') {
+                                if (cumulationBag.currentValue === aggregationReducer.initialValue ||
+                                    isAfter(parseDateValue(rowValue), parseDateValue(cumulationBag.currentValue))) {
+                                    cumulationBag.currentValue = rowValue;
+                                }
+                            }
+                            else if (rowValue > cumulationBag.currentValue) {
+                                cumulationBag.currentValue = rowValue;
+                            }
                         }
                         if (cumulationBag.currentValue !== aggregationReducer.initialValue) {
                             cumulationBag.cumulatedValues[rowNode.id] = cumulationBag.currentValue;

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

@@ -28,4 +28,4 @@ export declare const extractParameters: <T extends BaseParameter<string, string>
 }) => T[];
 export declare const handleColumnFunction: (args: any[], context: ExpressionContext) => ColumnParameter;
 export declare const getNumericValue: (input: unknown) => number;
-export declare const validateColumnType: (columnId: string, validColumnTypes: ('Number' | 'String' | 'Date')[], consumingFunction: string, api: AdaptableApi) => void;
+export declare const validateColumnType: (columnId: string, validColumnTypes: ('Number' | 'String' | 'Date')[], consumingFunction: string, api: AdaptableApi) => import("../../types").AdaptableColumnDataType;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -116,6 +116,7 @@ export const validateColumnType = (columnId, validColumnTypes, consumingFunction
     if (!validColumnTypes.some((validType) => validType === columnType)) {
         throw new ExpressionEvaluationError(consumingFunction, `expects a column of type ${validColumnTypes.join(' or ')}`);
     }
+    return columnType;
 };
 const validateColumnId = (columnId, api) => {
     const column = api.columnApi.getColumnWithColumnId(columnId);

package/src/Utilities/ObjectFactory.js

@@ -282,8 +282,6 @@ export function CreateEmptyCellSummmary() {
         Max: undefined,
         Min: undefined,
         Count: undefined,
-        Newest: undefined,
-        Oldest: undefined,
         Std_Deviation: undefined,
         Only: undefined,
     };

package/src/View/CellSummary/CellSummaryDetails.js

@@ -17,8 +17,9 @@ export class CellSummaryDetails extends React.Component {
         let data = [];
         if (this.props.CellSummary != null) {
             data = Object.keys(this.props.CellSummary).map((operationName) => {
+                const operationLabel = operationName === 'Std_Deviation' ? 'Standard Deviation' : operationName;
                 return {
-                    Operation: operationName,
+                    Operation: operationLabel,
                     Value: this.props.CellSummary[operationName],
                 };
             });

package/src/View/DataImport/DataImportPopup.js

@@ -8,7 +8,8 @@ export const DataImportPopup = (props) => {
     const [isWizardOpen, setIsWizardOpen] = React.useState(false);
     React.useEffect(() => {
         var _a, _b;
-        if (((_a = props.popupParams) === null || _a === void 0 ? void 0 : _a.action) === 'New' && ((_b = props.popupParams) === null || _b === void 0 ? void 0 : _b.source) !== 'ModuleMenu') {
+        if ((props === null || props === void 0 ? void 0 : props.popupParams) == undefined ||
+            (((_a = props.popupParams) === null || _a === void 0 ? void 0 : _a.action) === 'New' && ((_b = props.popupParams) === null || _b === void 0 ? void 0 : _b.source) !== 'ModuleMenu')) {
             setIsWizardOpen(true);
         }
     }, []);
@@ -20,7 +21,8 @@ export const DataImportPopup = (props) => {
         isWizardOpen && (React.createElement(DataImportWizard, { onClose: () => {
                 var _a;
                 setIsWizardOpen(false);
-                if (['Toolbar', 'ContextMenu', 'ColumnMenu', 'ModuleButton'].includes((_a = props === null || props === void 0 ? void 0 : props.popupParams) === null || _a === void 0 ? void 0 : _a.source)) {
+                if ((props === null || props === void 0 ? void 0 : props.popupParams) == undefined ||
+                    ['Toolbar', 'ContextMenu', 'ColumnMenu', 'ModuleButton'].includes((_a = props === null || props === void 0 ? void 0 : props.popupParams) === null || _a === void 0 ? void 0 : _a.source)) {
                     props.onClosePopup();
                 }
             } }))));

package/src/agGrid/ActionColumnRenderer.js

@@ -35,6 +35,10 @@ export const ReactActionColumnRenderer = (props) => {
     var _a, _b, _c;
     const rerender = useRerender();
     const adaptable = props.context.__adaptable;
+    if (!adaptable) {
+        console.warn('Adaptable not found in context of ActionColumnRenderer');
+        return null;
+    }
     const { actionButtons, actionColumn } = adaptable.api.internalApi.getActionButtonsAndActionColumn(props.colDef);
     if (!actionColumn || !actionButtons.length) {
         return null;
@@ -78,6 +82,10 @@ export class ActionColumnRenderer {
     init(params) {
         var _a, _b, _c;
         const adaptable = params.context.__adaptable;
+        if (!adaptable) {
+            console.warn('Adaptable not found in context of ActionColumnRenderer');
+            return null;
+        }
         const { actionButtons, actionColumn } = adaptable.api.internalApi.getActionButtonsAndActionColumn(params.colDef);
         if (!actionColumn || !actionButtons.length) {
             return;

package/src/agGrid/AdaptableAgGrid.js

@@ -993,11 +993,20 @@ export class AdaptableAgGrid {
      */
     async initializeAgGrid(gridOptions, modules, renderAgGridFrameworkComponent) {
         if (renderAgGridFrameworkComponent) {
+            console.log('renderAgGridFrameworkComponent');
             const result = await renderAgGridFrameworkComponent(gridOptions);
+            console.log('AFTER renderAgGridFrameworkComponent');
             if (result === false) {
                 return false;
             }
             const agGridApi = result;
+            // framework wrapper may have altered the context value via props
+            // in that case, we have to re-populate it with the Adaptable context values
+            const agGridContext = agGridApi.getGridOption('context');
+            if (!agGridContext.__adaptable) {
+                agGridContext.__adaptable = this;
+                agGridContext.adaptableApi = this.api;
+            }
             // framework wrapper may pass the rowData as a prop
             const rowData = agGridApi.getGridOption('rowData');
             this.initWithLazyData = rowData == undefined || rowData.length === 0;

package/src/agGrid/BadgeRenderer.js

@@ -10,11 +10,11 @@ export const getBadgeRendererForColumn = (badgeStyle, abColumn, api) => {
         init(params) {
             var _a, _b, _c, _d, _e, _f;
             const adaptable = this.getAdaptableInstance(params);
-            const adapatableApi = adaptable.api;
+            const adaptableApi = adaptable.api;
             this.eGui = document.createElement('div');
             this.eGui.className = 'ab-Badge__wrapper';
             const isGroupedRow = params.node.group;
-            const isSummaryRow = adapatableApi.gridApi.isSummaryNode(params.node);
+            const isSummaryRow = adaptableApi.gridApi.isSummaryNode(params.node);
             let shouldRender = true;
             if (isGroupedRow) {
                 if ((_a = badgeStyle.RowScope) === null || _a === void 0 ? void 0 : _a.ExcludeGroupRows) {
@@ -37,10 +37,10 @@ export const getBadgeRendererForColumn = (badgeStyle, abColumn, api) => {
                 return;
             }
             if (['NumberArray', 'StringArray'].includes(abColumn.dataType)) {
-                this.renderArrayValues(params, adapatableApi);
+                this.renderArrayValues(params, adaptableApi);
             }
             else {
-                this.renderSingularValues(params, adapatableApi);
+                this.renderSingularValues(params, adaptableApi);
             }
         }
         renderArrayValues(params, adapatableApi) {