@adaptabletools/adaptable 18.0.0-canary.0 → 18.0.0-canary.10

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -1,6 +1,7 @@
 import { extractColumnParameter, extractColumnParameters, extractParameter, getNumericValue, handleColumnFunction, validateColumnType, } from './expressionFunctionUtils';
 import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
 import { getTypedKeys } from '../Extensions/TypeExtensions';
+import { SumArray } from '../Extensions/ArrayExtensions';
 export const aggregatedExpressionFunctions = [
     'SUM',
     'PERCENTAGE',
@@ -11,6 +12,11 @@ export const aggregatedExpressionFunctions = [
     'WEIGHT',
     'COL',
     'GROUP_BY',
+    'MEDIAN',
+    'MODE',
+    'DISTINCT',
+    'ONLY',
+    'STD_DEVIATION',
 ];
 export const cumulativeAggregatedExpressionFunctions = [
     'CUMUL',
@@ -77,6 +83,8 @@ export const aggregatedScalarExpressionFunctions = {
                             field: sumColumnName,
                             initialValue: 0,
                             reducer: (totalSum, rowValue) => {
+                                // TODO: see why error are not concole logged
+                                // debuger = 'Adaptable:*'
                                 if (isUndefinedValue(rowValue)) {
                                     return totalSum;
                                 }
@@ -86,6 +94,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -148,6 +157,7 @@ export const aggregatedScalarExpressionFunctions = {
                         100);
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByColumnNames, aggregationExpressionEvaluation);
             const result = {
@@ -222,6 +232,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             if (weightParameter) {
@@ -246,6 +257,284 @@ export const aggregatedScalarExpressionFunctions = {
         examples: ['AVG([colA])', 'AVG([colA], GROUP_BY([colB]))', 'AVG([colA], WEIGHT([colB]))'],
         category: 'aggregation',
     },
+    MEDIAN: {
+        handler(args, context) {
+            const medianColumnParameter = extractColumnParameter('MEDIAN', args);
+            const medianColumnName = medianColumnParameter.value;
+            validateColumnType(medianColumnName, ['Number'], 'MEDIAN', context.adaptableApi);
+            const groupByParameter = extractParameter('MEDIAN', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const getCellValue = (rowNode) => {
+                return context.adaptableApi.gridApi.getNormalisedValueFromRowNode(rowNode, medianColumnName);
+            };
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        MEDIAN: {
+                            name: 'MEDIAN',
+                            field: medianColumnName,
+                            initialValue: [],
+                            reducer: (aggregatedValue, value, rowNode) => {
+                                aggregatedValue.push(rowNode);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                if (aggregatedValue.length === 0) {
+                                    return null;
+                                }
+                                if (aggregatedValue.length === 1) {
+                                    return getCellValue(aggregatedValue[0]);
+                                }
+                                const lenght = aggregatedValue.length;
+                                const middle = Math.floor((lenght - 1) / 2);
+                                if (lenght % 2) {
+                                    return getCellValue(aggregatedValue[middle]);
+                                }
+                                else {
+                                    return ((getCellValue(aggregatedValue[middle]) +
+                                        getCellValue(aggregatedValue[middle + 1])) /
+                                        2.0);
+                                }
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'MEDIAN',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the median of the column values\nOptionally the aggregation may be grouped.',
+        signatures: [
+            'MEDIAN( [colName] )',
+            'MEDIAN( COL(name: string))',
+            'MEDIAN( [colNameA], GROUP_BY( [colNameB] ))',
+            'MEDIAN( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['MEDIAN([colA])', 'MEDIAN([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
+    MODE: {
+        handler(args, context) {
+            const modeColumnParameter = extractColumnParameter('mode', args);
+            const modeColumnName = modeColumnParameter.value;
+            validateColumnType(modeColumnName, ['Number'], 'mode', context.adaptableApi);
+            const groupByParameter = extractParameter('MODE', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        MODE: {
+                            name: 'MODE',
+                            field: modeColumnName,
+                            initialValue: new Map(),
+                            reducer: (aggregatedValue, rowValue, rowNode) => {
+                                var _a;
+                                if (typeof rowValue !== 'number' && typeof rowValue !== 'string') {
+                                    return;
+                                }
+                                aggregatedValue.set(rowValue, ((_a = aggregatedValue.get(rowValue)) !== null && _a !== void 0 ? _a : 0) + 1);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                const sorted = [...aggregatedValue.entries()].sort(([aVal, aFreq], [bVal, bFreq]) => {
+                                    if (aFreq < bFreq) {
+                                        return 1;
+                                    }
+                                    else if (aFreq > bFreq || aVal < bVal) {
+                                        return -1;
+                                    }
+                                    else {
+                                        return aVal === bVal ? 0 : 1;
+                                    }
+                                });
+                                return sorted[0][0];
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'MODE',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the mode of the column values\nOptionally the aggregation may be grouped.',
+        signatures: [
+            'MODE( [colName] )',
+            'MODE( COL(name: string))',
+            'MODE( [colNameA], GROUP_BY( [colNameB] ))',
+            'MODE( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['MODE([colA])', 'MODE([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
+    DISTINCT: {
+        handler(args, context) {
+            const distinctColumnParameter = extractColumnParameter('DISTINCT', args);
+            const distinctColumnName = distinctColumnParameter.value;
+            const groupByParameter = extractParameter('MODE', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        DISTINCT: {
+                            name: 'DISTINCT',
+                            field: distinctColumnName,
+                            initialValue: new Set(),
+                            reducer: (aggregatedValue, rowValue, rowNode) => {
+                                if (typeof rowValue !== 'number' && typeof rowValue !== 'string') {
+                                    return aggregatedValue;
+                                }
+                                aggregatedValue.add(rowValue);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                return aggregatedValue.size;
+                            },
+                        },
+                    },
+                },
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'DISTINCT',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing the distinct number of the column values\nOptionally the aggregation may be grouped.',
+        signatures: [
+            'DISTINCT( [colName] )',
+            'DISTINCT( COL(name: string))',
+            'DISTINCT( [colNameA], GROUP_BY( [colNameB] ))',
+            'DISTINCT( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['DISTINCT([colA])', 'DISTINCT([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
+    ONLY: {
+        handler(args, context) {
+            const distinctColumnParameter = extractColumnParameter('ONLY', args);
+            const onlyColumnName = distinctColumnParameter.value;
+            validateColumnType(onlyColumnName, ['Number'], 'ONLY', context.adaptableApi);
+            const groupByParameter = extractParameter('ONLY', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        ONLY: {
+                            name: 'ONLY',
+                            field: onlyColumnName,
+                            initialValue: new Set(),
+                            reducer: (aggregatedValue, rowValue, rowNode) => {
+                                if (typeof rowValue !== 'number' && typeof rowValue !== 'string') {
+                                    return aggregatedValue;
+                                }
+                                aggregatedValue.add(rowValue);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                return aggregatedValue.size === 1 ? aggregatedValue.values().next().value : null;
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'ONLY',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing to a value that is common to all rows. \nOptionally the aggregation may be grouped.',
+        signatures: [
+            'ONLY( [colName] )',
+            'ONLY( COL(name: string))',
+            'ONLY( [colNameA], GROUP_BY( [colNameB] ))',
+            'ONLY( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['ONLY([colA])', 'ONLY([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
+    STD_DEVIATION: {
+        handler(args, context) {
+            const columnParameter = extractColumnParameter('STD_DEVIATION', args);
+            const columnName = columnParameter.value;
+            validateColumnType(columnName, ['Number'], 'STD_DEVIATION', context.adaptableApi);
+            const groupByParameter = extractParameter('STD_DEVIATION', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const aggregationExpressionEvaluation = {
+                aggregationParams: {
+                    reducers: {
+                        STD_DEVIATION: {
+                            name: 'STD_DEVIATION',
+                            field: columnName,
+                            initialValue: { sumOfValues: 0, values: [] },
+                            reducer: (aggregatedValue, rowValue, rowNode) => {
+                                // TODO: getNumericValue; allow numeric strings
+                                if (typeof rowValue !== 'number' || isNaN(rowValue)) {
+                                    return aggregatedValue;
+                                }
+                                aggregatedValue.sumOfValues = aggregatedValue.sumOfValues + rowValue;
+                                aggregatedValue.values.push(rowValue);
+                                return aggregatedValue;
+                            },
+                            done: (aggregatedValue) => {
+                                const { sumOfValues, values } = aggregatedValue;
+                                if (values.length === 0) {
+                                    return 0;
+                                }
+                                const mean = sumOfValues / values.length;
+                                const variance = SumArray(values.map((value) => Math.pow(value - mean, 2))) / values.length;
+                                return Math.sqrt(variance);
+                            },
+                        },
+                    },
+                },
+                rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
+            };
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            const result = {
+                name: 'STD_DEVIATION',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by computing to a value that is common to all rows. \nOptionally the aggregation may be grouped.',
+        signatures: [
+            'ONLY( [colName] )',
+            'ONLY( COL(name: string))',
+            'ONLY( [colNameA], GROUP_BY( [colNameB] ))',
+            'ONLY( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
+        ],
+        examples: ['ONLY([colA])', 'ONLY([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
+    },
     MIN: {
         handler(args, context) {
             const minColumnParameter = extractColumnParameter('MIN', args);
@@ -277,6 +566,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -327,6 +617,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -445,6 +736,7 @@ export const aggregatedScalarExpressionFunctions = {
                     const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
                     return isDefinedValue(rowValue);
                 },
+                getRowNodes: context.getRowNodes,
                 aggregationParams: {
                     reducers: {
                         QUANT: Object.assign({ name: 'QUANT', field: quantileColumnName }, quantReducer),
@@ -523,6 +815,7 @@ export const aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -745,6 +1038,7 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
         },
         rowValueGetter,
         rowFilterFn: aggregationEvaluation.rowFilterFn,
+        getRowNodes: context.getRowNodes,
     };
     return cumulationExpressionEvaluation;
 };

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -8,7 +8,7 @@ export function aggregate(aggregateParams, data) {
     const deepMap = new DeepMap();
     let currentGroupKeys = [];
     const getInitialReducerValue = () => {
-        return JSON.parse(JSON.stringify(initReducers(reducers)));
+        return structuredClone(initReducers(reducers));
     };
     const globalReducerResults = getInitialReducerValue();
     for (let i = 0, len = data.length; i < len; i++) {

package/src/Utilities/Extensions/ArrayExtensions.d.ts

@@ -32,6 +32,7 @@ export declare function sortCellValueArrayNumeric(cellValues: GridCell[], sortOr
 export declare function sortCellValueArrayDates(cellValues: GridCell[], sortOrder?: SortOrder): GridCell[];
 export declare function groupArrayBy(array: Array<any>, prop: string): Array<any>;
 export declare function createCommaSeparatedString(values: any[]): string;
+export declare function SumArray(array: (number | undefined)[]): number;
 export declare const ArrayExtensions: {
     GetLength: typeof GetLength;
     CorrectLength: typeof CorrectLength;
@@ -65,5 +66,6 @@ export declare const ArrayExtensions: {
     sortCellValueArrayDates: typeof sortCellValueArrayDates;
     sortArrayWithProperty: typeof sortArrayWithProperty;
     createCommaSeparatedString: typeof createCommaSeparatedString;
+    SumArray: typeof SumArray;
 };
 export default ArrayExtensions;

package/src/Utilities/Extensions/ArrayExtensions.js

@@ -254,6 +254,9 @@ export function groupArrayBy(array, prop) {
 export function createCommaSeparatedString(values) {
     return values.join(', ');
 }
+export function SumArray(array) {
+    return array.filter((num) => typeof num === 'number' && !isNaN(num)).reduce((a, b) => a + b, 0);
+}
 export const ArrayExtensions = {
     GetLength,
     CorrectLength,
@@ -287,5 +290,6 @@ export const ArrayExtensions = {
     sortCellValueArrayDates,
     sortArrayWithProperty,
     createCommaSeparatedString,
+    SumArray,
 };
 export default ArrayExtensions;

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

@@ -1,23 +1,22 @@
 import { AdaptableObject } from '../../PredefinedConfig/Common/AdaptableObject';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
-import { AdaptableOptions } from '../../AdaptableOptions/AdaptableOptions';
 import { AdaptableComparerFunction } from '../../PredefinedConfig/Common/AdaptableComparerFunction';
 import { PredefinedConfig } from '../../PredefinedConfig/PredefinedConfig';
 import { AccessLevel } from '../../PredefinedConfig/Common/Entitlement';
-export declare function assignAdaptableOptions(adaptableOptions: AdaptableOptions): AdaptableOptions;
 export declare function initPredefinedConfigWithUuids(predefinedConfig: PredefinedConfig): PredefinedConfig;
 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: {
-    assignAdaptableOptions: typeof assignAdaptableOptions;
     initPredefinedConfigWithUuids: typeof initPredefinedConfigWithUuids;
     checkValidPrimaryKey: typeof checkValidPrimaryKey;
     AdaptableObjectExistsInState: typeof AdaptableObjectExistsInState;
     runAdaptableComparerFunction: typeof runAdaptableComparerFunction;
     getAppropriateAccessLevel: typeof getAppropriateAccessLevel;
     addUuidAndSource: typeof addUuidAndSource;
+    removeUuidAndSource: typeof removeUuidAndSource;
 };
 export default AdaptableHelper;

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/ObjectFactory.js

@@ -28,10 +28,10 @@ export function CreateEmptyCalculatedColumn() {
         // need to create some defaults - which we will change later
         CalculatedColumnSettings: {
             DataType: undefined,
-            Filterable: false,
-            Resizable: false,
+            Filterable: true,
+            Resizable: true,
             Groupable: false,
-            Sortable: false,
+            Sortable: true,
             Pivotable: false,
             Aggregatable: false,
             SuppressMenu: false,
@@ -254,10 +254,10 @@ export function CreateEmptyFreeTextColumn() {
         TextEditor: 'Inline',
         FreeTextColumnSettings: {
             DataType: 'String',
-            Filterable: false,
-            Resizable: false,
+            Filterable: true,
+            Resizable: true,
             Groupable: false,
-            Sortable: false,
+            Sortable: true,
             Pivotable: false,
             Aggregatable: false,
             SuppressMenu: false,

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,11 @@ 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 computeAggregatedValue;
 }