@adaptabletools/adaptable-cjs 19.2.4 → 20.0.0-canary.0

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

@@ -7,10 +7,13 @@ import { AdaptableApi } from '../../../types';
 export declare class ModuleService implements IModuleService {
     private adaptableApi;
     constructor(adaptableApi: AdaptableApi);
-    createModuleMenus(): void;
     isModuleAvailable(adaptableModule: AdaptableModule): boolean;
     isModuleName(adaptableModule: string): adaptableModule is AdaptableModule;
     isModuleEditable(adaptableModule: AdaptableModule): boolean;
+    getModuleFriendlyName(adaptableModule: AdaptableModule): string;
+    createModuleUIItems(): void;
+    private createSettingsPanelItems;
+    private createModuleButtonsForDashboardAndToolPanel;
     getTeamSharingAction(adaptableModule: AdaptableModule): TeamSharingImportInfo<AdaptableObject> | undefined;
     getModuleById<T = IModule>(adaptableModule: AdaptableModule): T | undefined;
     getModuleInfoByModule(adaptableModule: AdaptableModule): ModuleInfo | undefined;

package/src/Utilities/Services/ModuleService.js

@@ -10,27 +10,6 @@ class ModuleService {
         this.adaptableApi = adaptableApi;
         this.adaptableApi = adaptableApi;
     }
-    createModuleMenus() {
-        const settingsPanelItems = [];
-        const adaptableMenuItems = [];
-        this.getModuleCollection().forEach((module) => {
-            const settingsPanelMenuItem = module.createModuleMenuItem('ModuleMenu');
-            if (Helper_1.default.objectExists(settingsPanelMenuItem)) {
-                if (settingsPanelItems.findIndex((m) => m.module == settingsPanelMenuItem.module) == -1) {
-                    settingsPanelItems.push(settingsPanelMenuItem);
-                }
-            }
-            const adaptableMenuItem = module.createModuleMenuItem('ModuleButton');
-            if (Helper_1.default.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) {
@@ -48,6 +27,39 @@ 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_1.default.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_1.default.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) {
@@ -73,8 +85,7 @@ 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

@@ -11,7 +11,6 @@ const expressionFunctionUtils_1 = require("../ExpressionFunctions/expressionFunc
 const observableExpressionFunctions_1 = require("../ExpressionFunctions/observableExpressionFunctions");
 const scalarExpressionFunctions_1 = require("../ExpressionFunctions/scalarExpressionFunctions");
 const TypeExtensions_1 = require("../Extensions/TypeExtensions");
-const ObjectFactory_1 = require("../ObjectFactory");
 const AggregatedScalarLiveValue_1 = require("./AggregatedScalarLiveValue");
 class QueryLanguageService {
     constructor(adaptableApi) {
@@ -22,16 +21,20 @@ 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) {
@@ -41,13 +44,11 @@ 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) {
@@ -55,12 +56,10 @@ 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$;
     }
@@ -69,17 +68,14 @@ 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)) {
@@ -94,7 +90,7 @@ 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) {
@@ -109,7 +105,7 @@ 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;
@@ -117,14 +113,19 @@ 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: '',
@@ -280,7 +281,6 @@ 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);
@@ -309,20 +309,18 @@ 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: (0, TypeExtensions_1.getTypedKeys)(generalBooleanExpressionFunctions),
                 availableScalarFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalScalarExpressionFunctions),
                 availableObservableFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalObservableExpressionFunctions),
                 availableAggregatedBooleanFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalAggregatedBooleanExpressionFunctions),
                 availableAggregatedScalarFunctionNames: (0, TypeExtensions_1.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),
@@ -335,8 +333,7 @@ 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 {};
         }
@@ -356,11 +353,11 @@ class QueryLanguageService {
             const expression = {
                 handler: (args, context) => {
                     const [aggColParam, ...restOfColParams] = (0, expressionFunctionUtils_1.extractColumnParameters)(expressionName, args);
-                    const aggColumnId = aggColParam === null || aggColParam === void 0 ? void 0 : aggColParam.value;
+                    const aggColumnId = aggColParam?.value;
                     const groupByParameter = (0, expressionFunctionUtils_1.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
@@ -380,20 +377,35 @@ 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) }, (0, ObjectFactory_1.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({}, (0, ObjectFactory_1.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;
@@ -403,35 +415,47 @@ class QueryLanguageService {
                         },
                         rowValueGetter: (rowNode, aggregationValue) => {
                             if (customExpressionDefinition.prepareRowValue) {
-                                const context = Object.assign(Object.assign({ rowNode: rowNode, aggregatedValue: aggregationValue }, (0, ObjectFactory_1.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 }, (0, ObjectFactory_1.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,
                     };
-                    (0, aggregatedScalarExpressionFunctions_1.addGroupByParams)(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+                    (0, aggregatedScalarExpressionFunctions_1.addGroupByParams)(groupByParameter?.value, aggregationExpressionEvaluation);
                     const result = {
                         name: expressionName,
                         type: 'aggregationScalar',
@@ -450,10 +474,8 @@ 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: (0, TypeExtensions_1.getTypedKeys)(availableExpressionFunctions),
+                ...this.adaptableApi.internalApi.buildBaseContext(),
             })
             : systemFunctions;
         let generalExpressionFunctions = {};
@@ -467,36 +489,34 @@ 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: (0, TypeExtensions_1.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,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowFormService = void 0;
+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
+    }
+}
+exports.RowFormService = RowFormService;

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?: {