@adaptabletools/adaptable-cjs 18.0.0-canary.1 → 18.0.0-canary.10

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -4,6 +4,7 @@ exports.aggregatedScalarExpressionFunctionNames = exports.aggregatedScalarExpres
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const TypeExtensions_1 = require("../Extensions/TypeExtensions");
+const ArrayExtensions_1 = require("../Extensions/ArrayExtensions");
 exports.aggregatedExpressionFunctions = [
     'SUM',
     'PERCENTAGE',
@@ -14,6 +15,11 @@ exports.aggregatedExpressionFunctions = [
     'WEIGHT',
     'COL',
     'GROUP_BY',
+    'MEDIAN',
+    'MODE',
+    'DISTINCT',
+    'ONLY',
+    'STD_DEVIATION',
 ];
 exports.cumulativeAggregatedExpressionFunctions = [
     'CUMUL',
@@ -80,6 +86,8 @@ exports.aggregatedScalarExpressionFunctions = {
                             field: sumColumnName,
                             initialValue: 0,
                             reducer: (totalSum, rowValue) => {
+                                // TODO: see why error are not concole logged
+                                // debuger = 'Adaptable:*'
                                 if (isUndefinedValue(rowValue)) {
                                     return totalSum;
                                 }
@@ -89,6 +97,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -151,6 +160,7 @@ exports.aggregatedScalarExpressionFunctions = {
                         100);
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByColumnNames, aggregationExpressionEvaluation);
             const result = {
@@ -225,6 +235,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             if (weightParameter) {
@@ -249,6 +260,284 @@ exports.aggregatedScalarExpressionFunctions = {
         examples: ['AVG([colA])', 'AVG([colA], GROUP_BY([colB]))', 'AVG([colA], WEIGHT([colB]))'],
         category: 'aggregation',
     },
+    MEDIAN: {
+        handler(args, context) {
+            const medianColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('MEDIAN', args);
+            const medianColumnName = medianColumnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(medianColumnName, ['Number'], 'MEDIAN', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.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 = (0, expressionFunctionUtils_1.extractColumnParameter)('mode', args);
+            const modeColumnName = modeColumnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(modeColumnName, ['Number'], 'mode', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.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 = (0, expressionFunctionUtils_1.extractColumnParameter)('DISTINCT', args);
+            const distinctColumnName = distinctColumnParameter.value;
+            const groupByParameter = (0, expressionFunctionUtils_1.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 = (0, expressionFunctionUtils_1.extractColumnParameter)('ONLY', args);
+            const onlyColumnName = distinctColumnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(onlyColumnName, ['Number'], 'ONLY', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.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 = (0, expressionFunctionUtils_1.extractColumnParameter)('STD_DEVIATION', args);
+            const columnName = columnParameter.value;
+            (0, expressionFunctionUtils_1.validateColumnType)(columnName, ['Number'], 'STD_DEVIATION', context.adaptableApi);
+            const groupByParameter = (0, expressionFunctionUtils_1.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 = (0, ArrayExtensions_1.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 = (0, expressionFunctionUtils_1.extractColumnParameter)('MIN', args);
@@ -280,6 +569,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -330,6 +620,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -448,6 +739,7 @@ exports.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),
@@ -526,6 +818,7 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
+                getRowNodes: context.getRowNodes,
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -748,6 +1041,7 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
         },
         rowValueGetter,
         rowFilterFn: aggregationEvaluation.rowFilterFn,
+        getRowNodes: context.getRowNodes,
     };
     return cumulationExpressionEvaluation;
 };

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -11,7 +11,7 @@ function aggregate(aggregateParams, data) {
     const deepMap = new deepMap_1.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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayExtensions = exports.createCommaSeparatedString = exports.groupArrayBy = exports.sortCellValueArrayDates = exports.sortCellValueArrayNumeric = exports.sortCellValueArray = exports.sortArray = exports.sortArrayWithProperty = exports.areArraysEqualWithOrderandProperties = exports.areArraysEqualWithOrder = exports.areArraysNotEqual = exports.areArraysEqual = exports.moveArray = exports.hasItemsOfCount = exports.hasOneItem = exports.getOccurrence = exports.HasSingleEmptyValue = exports.IsNotNullOrEmptyNorContainsSingleEmptyValue = exports.IsNullOrEmptyOrContainsSingleEmptyValue = exports.IsNotNullOrEmpty = exports.IsNullOrEmpty = exports.IsNotEmpty = exports.IsEmpty = exports.IsNotNull = exports.IsNull = exports.RetrieveDistinct = exports.NotContainsItem = exports.ContainsAnyItem = exports.ContainsItem = exports.AddItem = exports.NotCorrectLength = exports.CorrectLength = exports.GetLength = void 0;
+exports.ArrayExtensions = exports.SumArray = exports.createCommaSeparatedString = exports.groupArrayBy = exports.sortCellValueArrayDates = exports.sortCellValueArrayNumeric = exports.sortCellValueArray = exports.sortArray = exports.sortArrayWithProperty = exports.areArraysEqualWithOrderandProperties = exports.areArraysEqualWithOrder = exports.areArraysNotEqual = exports.areArraysEqual = exports.moveArray = exports.hasItemsOfCount = exports.hasOneItem = exports.getOccurrence = exports.HasSingleEmptyValue = exports.IsNotNullOrEmptyNorContainsSingleEmptyValue = exports.IsNullOrEmptyOrContainsSingleEmptyValue = exports.IsNotNullOrEmpty = exports.IsNullOrEmpty = exports.IsNotEmpty = exports.IsEmpty = exports.IsNotNull = exports.IsNull = exports.RetrieveDistinct = exports.NotContainsItem = exports.ContainsAnyItem = exports.ContainsItem = exports.AddItem = exports.NotCorrectLength = exports.CorrectLength = exports.GetLength = void 0;
 const Enums_1 = require("../../PredefinedConfig/Common/Enums");
 function GetLength(arrayToCheck) {
     return IsNotNull(arrayToCheck) ? arrayToCheck.length : 0;
@@ -289,6 +289,10 @@ function createCommaSeparatedString(values) {
     return values.join(', ');
 }
 exports.createCommaSeparatedString = createCommaSeparatedString;
+function SumArray(array) {
+    return array.filter((num) => typeof num === 'number' && !isNaN(num)).reduce((a, b) => a + b, 0);
+}
+exports.SumArray = SumArray;
 exports.ArrayExtensions = {
     GetLength,
     CorrectLength,
@@ -322,5 +326,6 @@ exports.ArrayExtensions = {
     sortCellValueArrayDates,
     sortArrayWithProperty,
     createCommaSeparatedString,
+    SumArray,
 };
 exports.default = exports.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,68 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptableHelper = exports.addUuidAndSource = exports.runAdaptableComparerFunction = exports.getAppropriateAccessLevel = exports.AdaptableObjectExistsInState = exports.checkValidPrimaryKey = exports.initPredefinedConfigWithUuids = exports.assignAdaptableOptions = 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"));
 const Uuid_1 = require("../../PredefinedConfig/Uuid");
-const DefaultAdaptableOptions_1 = require("../Defaults/DefaultAdaptableOptions");
-function assignAdaptableOptions(adaptableOptions) {
-    var _a;
-    const returnedAdaptableOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions, adaptableOptions);
-    returnedAdaptableOptions.adaptableStateKey =
-        (_a = returnedAdaptableOptions.adaptableStateKey) !== null && _a !== void 0 ? _a : returnedAdaptableOptions.adaptableId;
-    returnedAdaptableOptions.dataImportOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dataImportOptions, adaptableOptions.dataImportOptions);
-    returnedAdaptableOptions.expressionOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.expressionOptions, adaptableOptions.expressionOptions);
-    returnedAdaptableOptions.calendarOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.calendarOptions, adaptableOptions.calendarOptions);
-    returnedAdaptableOptions.columnOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.columnOptions, adaptableOptions.columnOptions);
-    returnedAdaptableOptions.customSortOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.customSortOptions, adaptableOptions.customSortOptions);
-    returnedAdaptableOptions.dataSetOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dataSetOptions, adaptableOptions.dataSetOptions);
-    returnedAdaptableOptions.cellSummaryOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.cellSummaryOptions, adaptableOptions.cellSummaryOptions);
-    returnedAdaptableOptions.predicateOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.predicateOptions, returnedAdaptableOptions.predicateOptions);
-    returnedAdaptableOptions.layoutOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.layoutOptions, adaptableOptions.layoutOptions);
-    returnedAdaptableOptions.notificationsOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.notificationsOptions, adaptableOptions.notificationsOptions);
-    returnedAdaptableOptions.alertOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.alertOptions, adaptableOptions.alertOptions);
-    returnedAdaptableOptions.flashingCellOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.flashingCellOptions, adaptableOptions.flashingCellOptions);
-    returnedAdaptableOptions.entitlementOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.entitlementOptions, adaptableOptions.entitlementOptions);
-    returnedAdaptableOptions.dashboardOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dashboardOptions, adaptableOptions.dashboardOptions);
-    returnedAdaptableOptions.editOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.editOptions, adaptableOptions.editOptions);
-    returnedAdaptableOptions.actionColumnOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionColumnOptions, adaptableOptions.actionColumnOptions);
-    // to do
-    returnedAdaptableOptions.actionRowOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionRowOptions, adaptableOptions.actionRowOptions);
-    returnedAdaptableOptions.actionRowOptions.actionRowButtonOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionRowOptions.actionRowButtonOptions, returnedAdaptableOptions.actionRowOptions.actionRowButtonOptions);
-    returnedAdaptableOptions.actionRowOptions.actionRowFormOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionRowOptions.actionRowFormOptions, returnedAdaptableOptions.actionRowOptions.actionRowFormOptions);
-    returnedAdaptableOptions.containerOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.containerOptions, adaptableOptions.containerOptions);
-    returnedAdaptableOptions.groupingOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.groupingOptions, adaptableOptions.groupingOptions);
-    returnedAdaptableOptions.quickSearchOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.quickSearchOptions, adaptableOptions.quickSearchOptions);
-    returnedAdaptableOptions.columnFilterOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.columnFilterOptions, adaptableOptions.columnFilterOptions);
-    returnedAdaptableOptions.columnFilterOptions.quickFilterOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.columnFilterOptions.quickFilterOptions, returnedAdaptableOptions.columnFilterOptions.quickFilterOptions);
-    returnedAdaptableOptions.columnFilterOptions.filterFormOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.columnFilterOptions.filterFormOptions, returnedAdaptableOptions.columnFilterOptions.filterFormOptions);
-    returnedAdaptableOptions.columnFilterOptions.valuesFilterOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.columnFilterOptions.valuesFilterOptions, returnedAdaptableOptions.columnFilterOptions.valuesFilterOptions);
-    returnedAdaptableOptions.gridFilterOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.gridFilterOptions, adaptableOptions.gridFilterOptions);
-    returnedAdaptableOptions.userInterfaceOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.userInterfaceOptions, adaptableOptions.userInterfaceOptions);
-    returnedAdaptableOptions.userInterfaceOptions.dateInputOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.userInterfaceOptions.dateInputOptions, returnedAdaptableOptions.userInterfaceOptions.dateInputOptions);
-    returnedAdaptableOptions.menuOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.menuOptions, adaptableOptions.menuOptions);
-    returnedAdaptableOptions.stateOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.stateOptions, adaptableOptions.stateOptions);
-    returnedAdaptableOptions.exportOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.exportOptions, adaptableOptions.exportOptions);
-    returnedAdaptableOptions.teamSharingOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.teamSharingOptions, adaptableOptions.teamSharingOptions);
-    returnedAdaptableOptions.toolPanelOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.toolPanelOptions, adaptableOptions.toolPanelOptions);
-    returnedAdaptableOptions.dataChangeHistoryOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dataChangeHistoryOptions, adaptableOptions.dataChangeHistoryOptions);
-    returnedAdaptableOptions.chartingOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.chartingOptions, adaptableOptions.chartingOptions);
-    returnedAdaptableOptions.chartingOptions.externalChartingOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.chartingOptions.externalChartingOptions, returnedAdaptableOptions.chartingOptions.externalChartingOptions);
-    returnedAdaptableOptions.settingsPanelOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.settingsPanelOptions, adaptableOptions.settingsPanelOptions);
-    returnedAdaptableOptions.fdc3Options = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.fdc3Options, adaptableOptions.fdc3Options);
-    returnedAdaptableOptions.fdc3Options.actionColumnDefaultConfiguration = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.fdc3Options.actionColumnDefaultConfiguration, returnedAdaptableOptions.fdc3Options.actionColumnDefaultConfiguration);
-    returnedAdaptableOptions.fdc3Options.uiControlsDefaultConfiguration = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.fdc3Options.uiControlsDefaultConfiguration, returnedAdaptableOptions.fdc3Options.uiControlsDefaultConfiguration);
-    const { predefinedConfig } = returnedAdaptableOptions;
-    if (predefinedConfig) {
-        returnedAdaptableOptions.predefinedConfig =
-            typeof predefinedConfig === 'string'
-                ? predefinedConfig
-                : initPredefinedConfigWithUuids(predefinedConfig);
-    }
-    return returnedAdaptableOptions;
-}
-exports.assignAdaptableOptions = assignAdaptableOptions;
 function initPredefinedConfigWithUuids(predefinedConfig) {
     const customizer = (value) => {
         // so whenever we clone a plain object,
@@ -154,13 +96,31 @@ function addUuidAndSource(adaptableObject) {
     return adaptableObject;
 }
 exports.addUuidAndSource = addUuidAndSource;
+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;
+}
+exports.removeUuidAndSource = removeUuidAndSource;
 exports.AdaptableHelper = {
-    assignAdaptableOptions,
     initPredefinedConfigWithUuids,
     checkValidPrimaryKey,
     AdaptableObjectExistsInState,
     runAdaptableComparerFunction,
     getAppropriateAccessLevel,
     addUuidAndSource,
+    removeUuidAndSource,
 };
 exports.default = exports.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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Helper = exports.clamp = exports.modeNumberArray = exports.medianNumberArray = exports.meanNumberArray = exports.standardDeviationNumberArray = exports.sumNumberArray = exports.roundNumberTo4dp = exports.roundNumber = exports.isInputNotNullOrEmpty = exports.isInputNullOrEmpty = exports.returnItemCount = exports.copyToClipboard = exports.createDownloadedFile = exports.convertArrayToCsv = exports.arrayToKeyMap = exports.cloneObject = exports.getStringRepresentionFromKey = exports.objectNotExists = exports.objectExists = void 0;
+exports.Helper = exports.clamp = exports.modeNumberArray = exports.medianNumberArray = exports.meanNumberArray = exports.standardDeviationNumberArray = exports.sumNumberArray = exports.roundNumberTo4dp = exports.roundNumber = exports.isInputNotNullOrEmpty = exports.isInputNullOrEmpty = exports.returnItemCount = exports.copyToClipboard = exports.createDownloadedFile = exports.convertArrayToCsv = exports.arrayToKeyMap = exports.cloneObject = exports.getStringRepresentionFromKey = exports.objectHasKeys = exports.objectNotExists = exports.objectExists = void 0;
 const StringExtensions_1 = require("../Extensions/StringExtensions");
 const AdaptableLogger_1 = require("../../agGrid/AdaptableLogger");
 function objectExists(item) {
@@ -11,6 +11,10 @@ function objectNotExists(item) {
     return !objectExists(item);
 }
 exports.objectNotExists = objectNotExists;
+function objectHasKeys(item) {
+    return Object.keys(item).length > 0;
+}
+exports.objectHasKeys = objectHasKeys;
 function getStringRepresentionFromKey(event) {
     if (event.key == null) {
         return event.char; // IE
@@ -249,6 +253,7 @@ exports.clamp = clamp;
 exports.Helper = {
     objectExists,
     objectNotExists,
+    objectHasKeys,
     getStringRepresentionFromKey,
     cloneObject,
     convertArrayToCsv,

package/src/Utilities/ObjectFactory.js

@@ -33,10 +33,10 @@ 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,
@@ -282,10 +282,10 @@ 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;
 }