@adaptabletools/adaptable 19.2.4 → 20.0.0-canary.0

package/src/Utilities/Services/ModuleService.js

@@ -6,27 +6,6 @@ export class ModuleService {
         this.adaptableApi = adaptableApi;
         this.adaptableApi = adaptableApi;
     }
-    createModuleMenus() {
-        const settingsPanelItems = [];
-        const adaptableMenuItems = [];
-        this.getModuleCollection().forEach((module) => {
-            const settingsPanelMenuItem = module.createModuleMenuItem('ModuleMenu');
-            if (Helper.objectExists(settingsPanelMenuItem)) {
-                if (settingsPanelItems.findIndex((m) => m.module == settingsPanelMenuItem.module) == -1) {
-                    settingsPanelItems.push(settingsPanelMenuItem);
-                }
-            }
-            const adaptableMenuItem = module.createModuleMenuItem('ModuleButton');
-            if (Helper.objectExists(adaptableMenuItem)) {
-                if (adaptableMenuItems.findIndex((m) => m.module == adaptableMenuItem.module) == -1) {
-                    adaptableMenuItems.push(adaptableMenuItem);
-                }
-            }
-        });
-        // store the main menu as we will re-use (and it never changes)
-        this.adaptableApi.internalApi.setSettingsPanelItems(settingsPanelItems);
-        this.adaptableApi.internalApi.setMenuModuleItems(adaptableMenuItems);
-    }
     isModuleAvailable(adaptableModule) {
         let module = this.getModuleCollection().get(adaptableModule);
         if (!module) {
@@ -44,6 +23,39 @@ export class ModuleService {
         }
         return module.isModuleEditable();
     }
+    getModuleFriendlyName(adaptableModule) {
+        return this.getModuleInfoByModule(adaptableModule)?.FriendlyName ?? adaptableModule;
+    }
+    createModuleUIItems() {
+        this.createSettingsPanelItems();
+        this.createModuleButtonsForDashboardAndToolPanel();
+    }
+    createSettingsPanelItems() {
+        const settingsPanelItems = [];
+        this.getModuleCollection().forEach((module) => {
+            const settingsPanelMenuItem = module.createModuleMenuItem('ModuleMenu');
+            if (Helper.objectExists(settingsPanelMenuItem)) {
+                if (settingsPanelItems.findIndex((m) => m.category == settingsPanelMenuItem.category) == -1) {
+                    settingsPanelItems.push(settingsPanelMenuItem);
+                }
+            }
+        });
+        // store Settings Panel items in Internal State as they never change and we often re-use
+        this.adaptableApi.internalApi.setSettingsPanelItems(settingsPanelItems);
+    }
+    createModuleButtonsForDashboardAndToolPanel() {
+        const moduleButtons = [];
+        this.getModuleCollection().forEach((module) => {
+            const moduleButton = module.createModuleMenuItem('ModuleButton');
+            if (Helper.objectExists(moduleButton)) {
+                if (moduleButtons.findIndex((m) => m.category == moduleButton.category) == -1) {
+                    moduleButtons.push(moduleButton);
+                }
+            }
+        });
+        // store Dashboard Buttons in Internal State as they never change l
+        this.adaptableApi.internalApi.setDashboardModuleButtons(moduleButtons);
+    }
     getTeamSharingAction(adaptableModule) {
         let module = this.getModuleCollection().get(adaptableModule);
         if (!module) {
@@ -69,8 +81,7 @@ export class ModuleService {
         return undefined;
     }
     getPopupMaxWidth(adaptableModule) {
-        var _a;
-        return (_a = this.getModuleById(adaptableModule)) === null || _a === void 0 ? void 0 : _a.getPopupMaxWidth();
+        return this.getModuleById(adaptableModule)?.getPopupMaxWidth();
     }
     getModuleCollection() {
         return this.adaptableApi.internalApi.getModules();

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

@@ -1,6 +1,6 @@
-import { IRowNode } from '@ag-grid-community/core';
+import { IRowNode } from 'ag-grid-enterprise';
 import { Observable } from 'rxjs';
-import { AdaptableApi, GridDataChangedInfo } from '../../../types';
+import { AdaptableApi, RowDataChangedInfo } from '../../../types';
 import { GlobalExpressionFunctionsContext } from '../../AdaptableOptions/ExpressionOptions';
 import { ExpressionFunction } from '../../parser/src/types';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
@@ -16,10 +16,10 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     private cacheAggregatedScalarValidation;
     private cacheModuleSpecificExpressionFunctions;
     constructor(adaptableApi: AdaptableApi);
-    evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
+    evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any, dataChangedEvent?: CellDataChangedInfo): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule, getRowNodes?: () => IRowNode[]): ScalarAggregationParameter;
-    evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo | GridDataChangedInfo>;
+    evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo | RowDataChangedInfo>;
     evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): BooleanAggregationParameter;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {
         force?: boolean;

package/src/Utilities/Services/QueryLanguageService.js

@@ -7,7 +7,6 @@ import { extractColumnParameters, extractParameter, } from '../ExpressionFunctio
 import { observableExpressionFunctions } from '../ExpressionFunctions/observableExpressionFunctions';
 import { scalarExpressionFunctions } from '../ExpressionFunctions/scalarExpressionFunctions';
 import { getTypedKeys } from '../Extensions/TypeExtensions';
-import { createBaseContext } from '../ObjectFactory';
 import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
 export class QueryLanguageService {
     constructor(adaptableApi) {
@@ -18,16 +17,20 @@ export class QueryLanguageService {
         this.cacheAggregatedScalarValidation = new Map();
         this.cacheModuleSpecificExpressionFunctions = new Map();
     }
-    evaluateBooleanExpression(expression, module, rowNode) {
+    evaluateBooleanExpression(expression, module, rowNode, dataChangedEvent) {
+        if (expression == undefined) {
+            // should never happen, but just in case
+            this.adaptableApi.logError('QueryLanguageService.evaluateBooleanExpression was called with an undefined expression');
+            return false;
+        }
         const moduleExpressionFunctions = this.getModuleExpressionFunctionsMap(module);
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         return parser.evaluate(expression, {
             node: rowNode,
-            adaptableApi: this.adaptableApi,
-            userName: this.adaptableApi.optionsApi.getUserName(),
-            adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
             functions: booleanAndScalarFunctions,
             evaluateCustomQueryVariable: this.evaluateCustomQueryVariable,
+            dataChangedEvent,
+            ...this.adaptableApi.internalApi.buildBaseContext(),
         });
     }
     evaluateScalarExpression(expression, module, rowNode) {
@@ -37,13 +40,11 @@ export class QueryLanguageService {
     evaluateAggregatedScalarExpression(expression, module, getRowNodes) {
         const aggregatedScalarFunctions = this.getModuleExpressionFunctionsMap(module).aggregatedScalarFunctions;
         return parser.evaluate(expression, {
-            node: null,
-            adaptableApi: this.adaptableApi,
-            userName: this.adaptableApi.optionsApi.getUserName(),
-            adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
+            node: null, // no node as this is an aggregation query
             functions: aggregatedScalarFunctions,
             evaluateCustomQueryVariable: this.evaluateCustomQueryVariable,
             getRowNodes,
+            ...this.adaptableApi.internalApi.buildBaseContext(),
         });
     }
     evaluateObservableExpression(reactiveExpression, module) {
@@ -51,12 +52,10 @@ export class QueryLanguageService {
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         const reactiveExpression$ = parser.evaluate(reactiveExpression, {
             node: this.adaptableApi.gridApi.getFirstRowNode(),
-            adaptableApi: this.adaptableApi,
-            userName: this.adaptableApi.optionsApi.getUserName(),
-            adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
             functions: moduleExpressionFunctions.observableFunctions,
             whereClauseFunctions: booleanAndScalarFunctions,
             evaluateCustomQueryVariable: this.evaluateCustomQueryVariable,
+            ...this.adaptableApi.internalApi.buildBaseContext(),
         });
         return reactiveExpression$;
     }
@@ -65,17 +64,14 @@ export class QueryLanguageService {
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctionsMap);
         const aggregationEvaluation = parser.evaluate(aggregationExpression, {
             node: this.adaptableApi.gridApi.getFirstRowNode(),
-            adaptableApi: this.adaptableApi,
-            userName: this.adaptableApi.optionsApi.getUserName(),
-            adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
             functions: moduleExpressionFunctionsMap.aggregatedBooleanFunctions,
             whereClauseFunctions: booleanAndScalarFunctions,
             evaluateCustomQueryVariable: this.evaluateCustomQueryVariable,
+            ...this.adaptableApi.internalApi.buildBaseContext(),
         });
         return aggregationEvaluation;
     }
     validateBoolean(expressionInput = '', module, config = { force: false }) {
-        var _a;
         const cacheKey = this.getExpressionCacheKey(expressionInput, module);
         try {
             if (this.cacheBooleanValidation.has(cacheKey)) {
@@ -90,7 +86,7 @@ export class QueryLanguageService {
                 this.cacheBooleanValidation.set(cacheKey, result);
                 return result;
             }
-            const force = (_a = config === null || config === void 0 ? void 0 : config.force) !== null && _a !== void 0 ? _a : false;
+            const force = config?.force ?? false;
             // see if validation should be performed
             if (!this.adaptableApi.optionsApi.getExpressionOptions().performExpressionValidation &&
                 !force) {
@@ -105,7 +101,7 @@ export class QueryLanguageService {
             if (rootFn.type === undefined || booleanAndScalarFunctions[rootFn.type] === undefined) {
                 const result = {
                     isValid: false,
-                    errorMessage: `provided function ${rootFn === null || rootFn === void 0 ? void 0 : rootFn.type} cannot be handled`,
+                    errorMessage: `provided function ${rootFn?.type} cannot be handled`,
                 };
                 this.cacheBooleanValidation.set(cacheKey, result);
                 return result;
@@ -113,14 +109,19 @@ export class QueryLanguageService {
             if (booleanAndScalarFunctions[rootFn.type].returnType !== 'boolean') {
                 const result = {
                     isValid: false,
-                    errorMessage: `provided function ${rootFn === null || rootFn === void 0 ? void 0 : rootFn.type} is not a predicate`,
+                    errorMessage: `provided function ${rootFn?.type} is not a predicate`,
                 };
                 this.cacheBooleanValidation.set(cacheKey, result);
                 return result;
             }
             // evaluating the expression is the only way to catch circular named query references
-            let firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
-            this.evaluateBooleanExpression(expression, module, firstRowNode);
+            const firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
+            // Mock datachangedevent for change-based functions e.g. PERCENT_CHANGE
+            const dataChangedEvent = {
+                newValue: 100,
+                oldValue: 150,
+            };
+            this.evaluateBooleanExpression(expression, module, firstRowNode, dataChangedEvent);
             const result = {
                 isValid: true,
                 errorMessage: '',
@@ -276,7 +277,6 @@ export class QueryLanguageService {
     // Returns the ExpressionFunctions available for the given Module as specified in the `QueryLanguageOptions.moduleExpressionFunctions`
     // if there are no specific functions defined, it falls back to the default values
     getModuleExpressionFunctionsMap(module) {
-        var _a, _b, _c;
         const expressionOptions = this.adaptableApi.optionsApi.getExpressionOptions();
         if (module) {
             let cachedResult = this.cacheModuleSpecificExpressionFunctions.get(module);
@@ -305,20 +305,18 @@ export class QueryLanguageService {
         let moduleExpressionFunctions;
         if (typeof expressionOptions.moduleExpressionFunctions === 'function') {
             const context = {
-                adaptableApi: this.adaptableApi,
-                userName: this.adaptableApi.optionsApi.getUserName(),
-                adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
                 module,
                 availableBooleanFunctionNames: getTypedKeys(generalBooleanExpressionFunctions),
                 availableScalarFunctionNames: getTypedKeys(generalScalarExpressionFunctions),
                 availableObservableFunctionNames: getTypedKeys(generalObservableExpressionFunctions),
                 availableAggregatedBooleanFunctionNames: getTypedKeys(generalAggregatedBooleanExpressionFunctions),
                 availableAggregatedScalarFunctionNames: getTypedKeys(generalAggregatedScalarExpressionFunctions),
+                ...this.adaptableApi.internalApi.buildBaseContext(),
             };
-            moduleExpressionFunctions = (_a = expressionOptions.moduleExpressionFunctions(context)) !== null && _a !== void 0 ? _a : {};
+            moduleExpressionFunctions = expressionOptions.moduleExpressionFunctions(context) ?? {};
         }
         else {
-            moduleExpressionFunctions = (_c = (_b = expressionOptions.moduleExpressionFunctions) === null || _b === void 0 ? void 0 : _b[module]) !== null && _c !== void 0 ? _c : {};
+            moduleExpressionFunctions = expressionOptions.moduleExpressionFunctions?.[module] ?? {};
         }
         const moduleExpressionFunctionsMap = {
             booleanFunctions: this.extractMappedExpressionFunctions(generalBooleanExpressionFunctions, moduleExpressionFunctions.systemBooleanFunctions, moduleExpressionFunctions.customBooleanFunctions),
@@ -331,8 +329,7 @@ export class QueryLanguageService {
         return moduleExpressionFunctionsMap;
     }
     getCustomAggregatedScalarFunctions() {
-        var _a;
-        const customAggregatedScalarFunctions = (_a = this.adaptableApi.optionsApi.getExpressionOptions()) === null || _a === void 0 ? void 0 : _a.customAggregatedFunctions;
+        const customAggregatedScalarFunctions = this.adaptableApi.optionsApi.getExpressionOptions()?.customAggregatedFunctions;
         if (!customAggregatedScalarFunctions) {
             return {};
         }
@@ -352,11 +349,11 @@ export class QueryLanguageService {
             const expression = {
                 handler: (args, context) => {
                     const [aggColParam, ...restOfColParams] = extractColumnParameters(expressionName, args);
-                    const aggColumnId = aggColParam === null || aggColParam === void 0 ? void 0 : aggColParam.value;
+                    const aggColumnId = aggColParam?.value;
                     const groupByParameter = extractParameter(expressionName, 'operand', ['GROUP_BY'], args, {
                         isOptional: true,
                     });
-                    const groupByColumnIds = groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value;
+                    const groupByColumnIds = groupByParameter?.value;
                     const contextArgs = args.filter((arg) => {
                         if (typeof arg === 'object' && arg.name === 'COL') {
                             // filter out aggregation column
@@ -376,20 +373,35 @@ export class QueryLanguageService {
                                     field: aggColumnId,
                                     initialValue: customExpressionDefinition.initialValue,
                                     reducer: (acc, value, rowNode, dataIndex) => {
-                                        const context = Object.assign({ accumulator: acc, currentValue: value, index: dataIndex, rowNode, args: contextArgs.map((arg) => {
+                                        const context = {
+                                            accumulator: acc,
+                                            currentValue: value,
+                                            index: dataIndex,
+                                            rowNode,
+                                            args: contextArgs.map((arg) => {
                                                 // if col, replace with value
                                                 if (typeof arg === 'object' && arg.name === 'COL') {
                                                     return getValueForColId(arg.value, rowNode);
                                                 }
                                                 return arg;
-                                            }), aggColumnId,
-                                            groupByColumnIds, getValueForColId: (colId) => getValueForColId(colId, rowNode) }, createBaseContext(this.adaptableApi));
+                                            }),
+                                            aggColumnId,
+                                            groupByColumnIds,
+                                            getValueForColId: (colId) => getValueForColId(colId, rowNode),
+                                            ...this.adaptableApi.internalApi.buildBaseContext(),
+                                        };
                                         return customExpressionDefinition.reducer(context);
                                     },
                                     done: (accValue, dataArray) => {
                                         if (customExpressionDefinition.processAggregatedValue) {
-                                            const context = Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { aggregatedValue: accValue, rowNodes: dataArray, args: contextArgs, aggColumnId,
-                                                groupByColumnIds });
+                                            const context = {
+                                                ...this.adaptableApi.internalApi.buildBaseContext(),
+                                                aggregatedValue: accValue,
+                                                rowNodes: dataArray,
+                                                args: contextArgs,
+                                                aggColumnId,
+                                                groupByColumnIds,
+                                            };
                                             return customExpressionDefinition.processAggregatedValue(context);
                                         }
                                         return accValue;
@@ -399,35 +411,47 @@ export class QueryLanguageService {
                         },
                         rowValueGetter: (rowNode, aggregationValue) => {
                             if (customExpressionDefinition.prepareRowValue) {
-                                const context = Object.assign(Object.assign({ rowNode: rowNode, aggregatedValue: aggregationValue }, createBaseContext(this.adaptableApi)), { args: contextArgs.map((arg) => {
+                                const context = {
+                                    rowNode: rowNode,
+                                    aggregatedValue: aggregationValue,
+                                    ...this.adaptableApi.internalApi.buildBaseContext(),
+                                    args: contextArgs.map((arg) => {
                                         // if col, replace with value
                                         if (typeof arg === 'object' && arg.name === 'COL') {
                                             return getValueForColId(arg.value, rowNode);
                                         }
                                         return arg;
-                                    }), aggColumnId,
-                                    groupByColumnIds, getValueForColId: (colId) => getValueForColId(colId, rowNode) });
+                                    }),
+                                    aggColumnId,
+                                    groupByColumnIds,
+                                    getValueForColId: (colId) => getValueForColId(colId, rowNode),
+                                };
                                 return customExpressionDefinition.prepareRowValue(context);
                             }
                             return aggregationValue;
                         },
                         rowFilterFn: (rowNode) => {
-                            var _a, _b;
                             if (customExpressionDefinition.filterRow) {
-                                return customExpressionDefinition.filterRow(Object.assign(Object.assign({ rowNode }, createBaseContext(this.adaptableApi)), { args: contextArgs.map((arg) => {
+                                return customExpressionDefinition.filterRow({
+                                    rowNode,
+                                    ...this.adaptableApi.internalApi.buildBaseContext(),
+                                    args: contextArgs.map((arg) => {
                                         // if col, replace with value
                                         if (typeof arg === 'object' && arg.name === 'COL') {
                                             return getValueForColId(arg.value, rowNode);
                                         }
                                         return arg;
-                                    }), aggColumnId,
-                                    groupByColumnIds, getValueForColId: (colId) => getValueForColId(colId, rowNode) }));
+                                    }),
+                                    aggColumnId,
+                                    groupByColumnIds,
+                                    getValueForColId: (colId) => getValueForColId(colId, rowNode),
+                                });
                             }
-                            return (_b = (_a = context === null || context === void 0 ? void 0 : context.filterFn) === null || _a === void 0 ? void 0 : _a.call(context, rowNode)) !== null && _b !== void 0 ? _b : true;
+                            return context?.filterFn?.(rowNode) ?? true;
                         },
                         getRowNodes: context.getRowNodes,
                     };
-                    addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+                    addGroupByParams(groupByParameter?.value, aggregationExpressionEvaluation);
                     const result = {
                         name: expressionName,
                         type: 'aggregationScalar',
@@ -446,10 +470,8 @@ export class QueryLanguageService {
     extractMappedExpressionFunctions(availableExpressionFunctions, systemFunctions, customFunctions) {
         const systemFunctionNames = typeof systemFunctions === 'function'
             ? systemFunctions({
-                adaptableApi: this.adaptableApi,
-                userName: this.adaptableApi.optionsApi.getUserName(),
-                adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
                 availableExpressionFunctionNames: getTypedKeys(availableExpressionFunctions),
+                ...this.adaptableApi.internalApi.buildBaseContext(),
             })
             : systemFunctions;
         let generalExpressionFunctions = {};
@@ -463,36 +485,34 @@ export class QueryLanguageService {
         }
         else {
             // add ALL system functions
-            generalExpressionFunctions = Object.assign({}, availableExpressionFunctions);
+            generalExpressionFunctions = { ...availableExpressionFunctions };
         }
         const customFunctionDefinitions = typeof customFunctions === 'function'
             ? customFunctions({
-                adaptableApi: this.adaptableApi,
-                userName: this.adaptableApi.optionsApi.getUserName(),
-                adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
                 availableExpressionFunctionNames: getTypedKeys(generalExpressionFunctions),
+                ...this.adaptableApi.internalApi.buildBaseContext(),
             })
             : customFunctions;
         if (customFunctionDefinitions) {
-            generalExpressionFunctions = Object.assign(Object.assign({}, generalExpressionFunctions), customFunctionDefinitions);
+            generalExpressionFunctions = { ...generalExpressionFunctions, ...customFunctionDefinitions };
         }
         return generalExpressionFunctions;
     }
     evaluateCustomQueryVariable(functionName, args) {
-        var _a, _b;
         const context = {
-            adaptableApi: this.adaptableApi,
-            userName: this.adaptableApi.optionsApi.getUserName(),
-            adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
             args,
+            ...this.adaptableApi.internalApi.buildBaseContext(),
         };
-        const customQueryVariableDefinition = (_b = (_a = this.adaptableApi.optionsApi.getExpressionOptions()) === null || _a === void 0 ? void 0 : _a.customQueryVariables) === null || _b === void 0 ? void 0 : _b[functionName];
+        const customQueryVariableDefinition = this.adaptableApi.optionsApi.getExpressionOptions()?.customQueryVariables?.[functionName];
         return typeof customQueryVariableDefinition === 'function'
             ? customQueryVariableDefinition(context)
             : customQueryVariableDefinition;
     }
     getBooleanAndScalarFunctions(moduleExpressionFunctionsMap) {
-        return Object.assign(Object.assign({}, moduleExpressionFunctionsMap.booleanFunctions), moduleExpressionFunctionsMap.scalarFunctions);
+        return {
+            ...moduleExpressionFunctionsMap.booleanFunctions,
+            ...moduleExpressionFunctionsMap.scalarFunctions,
+        };
     }
     getExpressionCacheKey(expression, module) {
         return `${module}::${expression}`;

package/src/Utilities/Services/{RowEditService.d.ts → RowFormService.d.ts}

@@ -1,8 +1,8 @@
 import { AdaptableApi } from '../../Api/AdaptableApi';
 import { IAdaptableService } from './Interface/IAdaptableService';
-export declare class RowEditService implements IAdaptableService {
+export declare class RowFormService implements IAdaptableService {
     private adaptableApi;
     constructor(adaptableApi: AdaptableApi);
-    private autoHandleActionRowButtons;
+    private autoHandleRowFormButtons;
     destroy(): void;
 }

package/src/Utilities/Services/RowFormService.js

@@ -0,0 +1,45 @@
+export class RowFormService {
+    constructor(adaptableApi) {
+        this.adaptableApi = adaptableApi;
+        if (adaptableApi.optionsApi.getRowFormOptions().autoHandle) {
+            adaptableApi.eventApi.on('RowFormSubmitted', (eventInfo) => this.autoHandleRowFormButtons(eventInfo));
+        }
+    }
+    autoHandleRowFormButtons(rowFormSubmittedInfo) {
+        const { adaptableApi } = rowFormSubmittedInfo;
+        if (rowFormSubmittedInfo.type === 'rowEdited') {
+            const { rowNode, formData } = rowFormSubmittedInfo;
+            const newRowData = {
+                ...rowNode.data,
+                ...formData,
+            };
+            adaptableApi.gridApi.updateGridData([newRowData]);
+        }
+        if (rowFormSubmittedInfo.type === 'rowDeleted') {
+            const { rowNode } = rowFormSubmittedInfo;
+            const deletedRowData = rowNode.data;
+            adaptableApi.gridApi.deleteGridData([deletedRowData]);
+        }
+        if (rowFormSubmittedInfo.type === 'rowCreated') {
+            const { formData } = rowFormSubmittedInfo;
+            let newRowData = formData;
+            const setPrimaryKeyValueFunction = adaptableApi.optionsApi.getRowFormOptions().setPrimaryKeyValue;
+            if (setPrimaryKeyValueFunction) {
+                const context = {
+                    rowData: formData,
+                    ...adaptableApi.internalApi.buildBaseContext(),
+                };
+                const pkValue = setPrimaryKeyValueFunction(context);
+                const primaryKeyColumn = this.adaptableApi.columnApi.getPrimaryKeyColumn();
+                newRowData[primaryKeyColumn.columnId] = pkValue;
+            }
+            const config = {
+                addIndex: 0,
+            };
+            adaptableApi.gridApi.addGridData([newRowData], config);
+        }
+    }
+    destroy() {
+        // nothing yet
+    }
+}

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

@@ -1,4 +1,4 @@
-import { AdaptableApi, Layout } from '../../types';
+import { AdaptableApi, TableLayout } from '../../types';
 import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
 /**
  * The logic is extracted here to make it easier to follow
@@ -7,9 +7,9 @@ export declare class RowSummaryService {
     private api;
     cachedCellSummary: Map<string, AggregatedScalarLiveValue>;
     previousRowSummaries: any;
-    previousLayout: Layout | null;
+    previousLayout: TableLayout | null;
     constructor(api: AdaptableApi);
-    onAdapterReady(): void;
+    onAdaptableReady(): void;
     rowSummariesSubscriptions(): void;
     _throttleAcumulatedColumnsThatChanged: Set<string>;
     throttledEvaluateRowSummary(reason?: {

package/src/Utilities/Services/RowSummaryService.js

@@ -1,5 +1,5 @@
 import { ROW_SUMMARY_ROW_ID, WEIGHTED_AVERAGE_AGGREATED_FUNCTION, } from '../../PredefinedConfig/Common/RowSummary';
-import { SystemRowSummarySet } from '../../Redux/ActionsReducers/SystemRedux';
+import { RowSummarySet } from '../../Redux/ActionsReducers/InternalRedux';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import Helper from '../Helpers/Helper';
 import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
@@ -20,7 +20,7 @@ export class RowSummaryService {
          */
         this._throttledEvaluateRowSummary = throttle(this.evaluateRowSummary, 300);
     }
-    onAdapterReady() {
+    onAdaptableReady() {
         this.rowSummariesSubscriptions();
     }
     rowSummariesSubscriptions() {
@@ -36,11 +36,13 @@ export class RowSummaryService {
         this.api.eventApi.on('AdaptableStateReloaded', () => {
             this.throttledEvaluateRowSummary();
         });
-        this.api.eventApi.on('GridDataChanged', (event) => {
+        this.api.internalApi
+            .getDataService()
+            .on('RowDataChanged', (rowDataChangedInfo) => {
             this.throttledEvaluateRowSummary();
         });
         this.api.eventApi.on('CellChanged', (event) => {
-            const columnId = event.cellChange.column.columnId;
+            const columnId = event.cellDataChange.column.columnId;
             this.throttledEvaluateRowSummary({
                 columnIds: [columnId],
             });
@@ -57,8 +59,7 @@ export class RowSummaryService {
         });
         const adaptable = this.api.internalApi.getAdaptableInstance();
         adaptable._on('AdapTableFiltersApplied', () => {
-            // we need to use this instead of layout changed
-            // so the rows have time to update
+            // we need to use this instead of layout changed so the rows have time to update
             this.throttledEvaluateRowSummary();
         });
         adaptable._on('FirstDataRendered', () => {
@@ -72,7 +73,6 @@ export class RowSummaryService {
         this._throttledEvaluateRowSummary(reason);
     }
     evaluateRowSummary(reason) {
-        var _a;
         if (this._throttleAcumulatedColumnsThatChanged.size > 0) {
             const columnIds = Array.from(this._throttleAcumulatedColumnsThatChanged.values());
             reason = {
@@ -80,7 +80,7 @@ export class RowSummaryService {
             };
             this._throttleAcumulatedColumnsThatChanged.clear();
         }
-        if (this.api.isDestroyed()) {
+        if (this.api.isDestroyed() || this.api.layoutApi.isCurrentLayoutPivot()) {
             return;
         }
         const currentLayout = this.api.layoutApi.getCurrentLayout();
@@ -90,10 +90,14 @@ export class RowSummaryService {
         /**
          * If the previous & current layout does not have row summaries, it is safe to exit
          */
-        if (isObjectEmpty(currentLayout === null || currentLayout === void 0 ? void 0 : currentLayout.RowSummaries) && isObjectEmpty(previousLayout === null || previousLayout === void 0 ? void 0 : previousLayout.RowSummaries)) {
+        if (isObjectEmpty(currentLayout?.RowSummaries) && isObjectEmpty(previousLayout?.RowSummaries)) {
             return;
         }
-        const rowSummaries = (_a = this.api.layoutApi.getCurrentLayout().RowSummaries) !== null && _a !== void 0 ? _a : [];
+        const rowSummaries = currentLayout.RowSummaries ?? [];
+        const aggColsMap = (currentLayout.TableAggregationColumns || []).reduce((acc, { ColumnId, AggFunc }) => {
+            acc[ColumnId] = AggFunc;
+            return acc;
+        }, {});
         const rowSummariesResults = rowSummaries
             .filter((rowSummary) => !rowSummary.IsSuspended)
             .map((rowSummary, index) => {
@@ -102,9 +106,8 @@ export class RowSummaryService {
             IncludeOnlyFilteredRows = true, } = rowSummary;
             return {
                 Position,
-                RowData: Object.entries(ColumnsMap !== null && ColumnsMap !== void 0 ? ColumnsMap : {}).reduce((acc, [columnId, expression]) => {
-                    var _a, _b;
-                    if (columnId === 'Uuid' || columnId === 'Source') {
+                RowData: Object.entries(ColumnsMap ?? {}).reduce((acc, [columnId, expression]) => {
+                    if (columnId === 'Uuid' || columnId === 'Source' || columnId === 'AdaptableVersion') {
                         return acc;
                     }
                     const key = `${columnId}-${expression}-IncludeOnlyFilteredRows=${IncludeOnlyFilteredRows ? 'filtered' : 'all'}`;
@@ -122,10 +125,9 @@ export class RowSummaryService {
                         try {
                             let aggregatedScalarExpression = `${expression}([${columnId}])`;
                             if (aggregatedScalarExpression.includes(WEIGHTED_AVERAGE_AGGREATED_FUNCTION) &&
-                                currentLayout.AggregationColumns[columnId] &&
-                                typeof currentLayout.AggregationColumns[columnId] === 'object') {
-                                const weight = currentLayout.AggregationColumns[columnId]
-                                    .weightedColumnId;
+                                aggColsMap[columnId] &&
+                                typeof aggColsMap[columnId] === 'object') {
+                                const weight = aggColsMap[columnId].weightedColumnId;
                                 if (weight) {
                                     aggregatedScalarExpression = `AVG([${columnId}], WEIGHT([${weight}]))`;
                                 }
@@ -133,8 +135,7 @@ export class RowSummaryService {
                             expressionLiveValue = new AggregatedScalarLiveValue({
                                 aggregatedScalarExpression,
                             }, ModuleConstants.LayoutModuleId, this.api, () => {
-                                var _a;
-                                if ((_a = rowSummary.IncludeOnlyFilteredRows) !== null && _a !== void 0 ? _a : true) {
+                                if (rowSummary.IncludeOnlyFilteredRows ?? true) {
                                     return this.api.gridApi.getVisibleRowNodes();
                                 }
                                 else {
@@ -155,7 +156,7 @@ export class RowSummaryService {
                         }
                     }
                     const column = this.api.columnApi.getColumnWithColumnId(columnId);
-                    const fieldName = (_b = (_a = column === null || column === void 0 ? void 0 : column.field) !== null && _a !== void 0 ? _a : column === null || column === void 0 ? void 0 : column.columnId) !== null && _b !== void 0 ? _b : columnId;
+                    const fieldName = column?.field ?? column?.columnId ?? columnId;
                     acc = this.api.internalApi.setValueUsingField(acc, fieldName, value);
                     return acc;
                 }, {
@@ -166,7 +167,7 @@ export class RowSummaryService {
         if (this.previousRowSummaries && isEqual(rowSummariesResults, this.previousRowSummaries)) {
             return;
         }
-        this.api.internalApi.dispatchReduxAction(SystemRowSummarySet(rowSummariesResults));
+        this.api.internalApi.dispatchReduxAction(RowSummarySet(rowSummariesResults));
         this.previousRowSummaries = rowSummariesResults;
     }
 }