@adaptabletools/adaptable 18.0.0-canary.8 → 18.0.0

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

@@ -16,7 +16,7 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     constructor(adaptableApi: AdaptableApi);
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
-    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): ScalarAggregationParameter;
+    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule, getRowNodes?: () => IRowNode[]): ScalarAggregationParameter;
     evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo | GridDataChangedInfo>;
     evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): BooleanAggregationParameter;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {

package/src/Utilities/Services/QueryLanguageService.js

@@ -32,7 +32,7 @@ export class QueryLanguageService {
         // currently scalar and boolean expressions are evaluated the same
         return this.evaluateBooleanExpression(expression, module, rowNode);
     }
-    evaluateAggregatedScalarExpression(expression, module) {
+    evaluateAggregatedScalarExpression(expression, module, getRowNodes) {
         const aggregatedScalarFunctions = this.getModuleExpressionFunctionsMap(module).aggregatedScalarFunctions;
         return parser.evaluate(expression, {
             node: null,
@@ -41,13 +41,14 @@ export class QueryLanguageService {
             adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
             functions: aggregatedScalarFunctions,
             evaluateCustomQueryVariable: this.evaluateCustomQueryVariable,
+            getRowNodes,
         });
     }
     evaluateObservableExpression(reactiveExpression, module) {
         const moduleExpressionFunctions = this.getModuleExpressionFunctionsMap(module);
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         const reactiveExpression$ = parser.evaluate(reactiveExpression, {
-            node: reactiveExpression,
+            node: this.adaptableApi.gridApi.getFirstRowNode(),
             adaptableApi: this.adaptableApi,
             userName: this.adaptableApi.optionsApi.getUserName(),
             adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
@@ -61,7 +62,7 @@ export class QueryLanguageService {
         const moduleExpressionFunctionsMap = this.getModuleExpressionFunctionsMap(module);
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctionsMap);
         const aggregationEvaluation = parser.evaluate(aggregationExpression, {
-            node: aggregationExpression,
+            node: this.adaptableApi.gridApi.getFirstRowNode(),
             adaptableApi: this.adaptableApi,
             userName: this.adaptableApi.optionsApi.getUserName(),
             adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),

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

@@ -10,11 +10,8 @@ export declare class ReportService implements IReportService {
     private cellClassKey2excelStyleIdMap;
     private excelStylesWithFormattedDate;
     constructor(adaptableApi: AdaptableApi);
-    resetExcelStyleMemoization(): void;
-    registerExcelStyle(excelStyle: Partial<ExcelStyle>, cellClassKey: string): void;
-    getRegisteredExcelStyles(): ExcelStyle[];
+    destroy(): void;
     getExcelStyleIdForCellClassKey(cellClassKey: string): string;
-    registerExcelStyleWithFormattedDate(cellClassId: string, isoFormattedValue: string): void;
     getExcelStyleWithFormattedDate(cellClassId: string): string;
     CreateSystemReport(systemReportName: SystemReportName): Report;
     IsSystemReport(reportName: string): boolean;
@@ -33,7 +30,12 @@ export declare class ReportService implements IReportService {
     getCellExportValueFromRowNode(rowNode: IRowNode, columnId: string): any;
     getCellExportValueFromRawValue(rowNode: IRowNode, cellRawValue: any, columnId: string): any;
     getReportFileName(reportName: string, destination: SystemExportDestination | CustomDestination): string;
-    destroy(): void;
     private getCustomExportDateFormat;
     private getCellExportValueFromRawValueByType;
+    buildExcelStylesForVisualReports(): ExcelStyle[];
+    createExcelStyleMemoization(): void;
+    private convertCSSToExcelStyle;
+    private resetExcelStyleMemoization;
+    private registerExcelStyle;
+    private registerExcelStyleWithFormattedDate;
 }

package/src/Utilities/Services/ReportService.js

@@ -7,6 +7,8 @@ import StringExtensions from '../Extensions/StringExtensions';
 import { ExportModuleId } from '../Constants/ModuleConstants';
 import { createUuid } from '../../components/utils/uuid';
 import { createBaseContext } from '../ObjectFactory';
+import { convertCSSAbsoluteFontSizeToPt, getVariableColor, sanitizeStyle, } from '../Helpers/StyleHelper';
+import tinycolor from 'tinycolor2';
 export class ReportService {
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
@@ -15,29 +17,12 @@ export class ReportService {
         this.excelStylesWithFormattedDate = {};
         this.adaptableApi = adaptableApi;
     }
-    resetExcelStyleMemoization() {
-        this.excelStylesCache = {};
-        this.cellClassKey2excelStyleIdMap = {};
-        this.excelStylesWithFormattedDate = {};
-    }
-    registerExcelStyle(excelStyle, cellClassKey) {
-        const excelStyleKey = JSON.stringify(excelStyle);
-        if (!this.excelStylesCache[excelStyleKey]) {
-            const excelStyleId = createUuid();
-            const excelStyleWithId = Object.assign(Object.assign({}, excelStyle), { id: excelStyleId });
-            this.excelStylesCache[excelStyleKey] = excelStyleWithId;
-        }
-        this.cellClassKey2excelStyleIdMap[cellClassKey] = this.excelStylesCache[excelStyleKey].id;
-    }
-    getRegisteredExcelStyles() {
-        return Object.values(this.excelStylesCache);
+    destroy() {
+        // TO DO
     }
     getExcelStyleIdForCellClassKey(cellClassKey) {
         return this.cellClassKey2excelStyleIdMap[cellClassKey];
     }
-    registerExcelStyleWithFormattedDate(cellClassId, isoFormattedValue) {
-        this.excelStylesWithFormattedDate[cellClassId] = isoFormattedValue;
-    }
     getExcelStyleWithFormattedDate(cellClassId) {
         return this.excelStylesWithFormattedDate[cellClassId];
     }
@@ -99,8 +84,11 @@ export class ReportService {
             reportName == VISUAL_DATA_REPORT);
     }
     IsSystemReportActive(reportName) {
-        if (reportName == SELECTED_CELLS_REPORT || reportName == SELECTED_ROWS_REPORT) {
-            return this.adaptableApi.gridApi.isGridSelectable();
+        if (reportName == SELECTED_CELLS_REPORT) {
+            return this.adaptableApi.gridApi.isGridRangeSelectable();
+        }
+        if (reportName == SELECTED_ROWS_REPORT) {
+            return this.adaptableApi.gridApi.isGridRowSelectable();
         }
         if (reportName === VISUAL_DATA_REPORT) {
             return this.adaptableApi.exportApi
@@ -146,7 +134,7 @@ export class ReportService {
             case 'SelectedColumns':
                 return '[Selected Columns]';
             case 'ScopeColumns':
-                return this.adaptableApi.scopeApi.getScopeDescription(report.Scope);
+                return this.adaptableApi.columnScopeApi.getScopeDescription(report.Scope);
         }
     }
     GetReportExpressionDescription(report, cols) {
@@ -209,7 +197,7 @@ export class ReportService {
                     reportColumns = report.Scope.ColumnIds.map((columnId) => this.adaptableApi.columnApi.getColumnWithColumnId(columnId)).filter((c) => c);
                 }
                 else {
-                    reportColumns = this.adaptableApi.scopeApi.getColumnsForScope(report.Scope);
+                    reportColumns = this.adaptableApi.columnScopeApi.getColumnsForScope(report.Scope);
                 }
                 break;
         }
@@ -365,9 +353,6 @@ export class ReportService {
         }
         return fileName;
     }
-    destroy() {
-        // TO DO
-    }
     getCustomExportDateFormat() {
         return this.adaptableApi.optionsApi.getExportOptions().exportDateFormat;
     }
@@ -379,4 +364,238 @@ export class ReportService {
             : // type === formattedValue
                 this.adaptableApi.gridApi.getDisplayValueFromRawValue(rowNode, columnId, cellRawValue);
     }
+    // aggregate and merge all acive Adaptable styles with the user proviided ExcelStyles
+    buildExcelStylesForVisualReports() {
+        // for historical reasons, the styles are merged as class variables
+        // we could/should refactor this to be more functional
+        this.createExcelStyleMemoization();
+        return Object.values(this.excelStylesCache);
+    }
+    createExcelStyleMemoization() {
+        this.resetExcelStyleMemoization();
+        // we memoize as much as possible, as this is called quite A LOT
+        const adaptableColumnMap = {};
+        const getAdaptableColumnWithColumnId = (columnId) => {
+            const memoizedColumn = adaptableColumnMap[columnId];
+            if (memoizedColumn) {
+                return memoizedColumn;
+            }
+            const abColumn = this.adaptableApi.columnApi.getColumnWithColumnId(columnId);
+            adaptableColumnMap[columnId] = abColumn;
+            return abColumn;
+        };
+        const formatColumnsWithDisplayFormatForColumn = {};
+        const getFormatColumnsWithDisplayFormatForColumn = (columnId) => {
+            const memoizedFormatColumns = formatColumnsWithDisplayFormatForColumn[columnId];
+            if (memoizedFormatColumns) {
+                return memoizedFormatColumns;
+            }
+            const abColumn = getAdaptableColumnWithColumnId(columnId);
+            const formatColumns = this.adaptableApi.formatColumnApi.internalApi.getFormatColumnsWithDisplayFormatForColumn(abColumn);
+            formatColumnsWithDisplayFormatForColumn[columnId] = formatColumns;
+            return formatColumns;
+        };
+        const isDateCellExportedAsFormattedValue = this.adaptableApi.exportApi.internalApi.isDateCellExportedAsFormattedValue();
+        const displayedColumns = this.adaptableApi.agGridApi.getAllDisplayedColumns();
+        const colDefs = displayedColumns.map((column) => {
+            return column.getColDef();
+        });
+        const forAllVisibleRowNodesDoConfig = { includeGroupRows: true };
+        const agGridApi = this.adaptableApi.agGridApi;
+        const userExcelStyles = this.adaptableApi.internalApi
+            .getAdaptableInstance()
+            .agGridAdapter.getUserGridOptionsProperty('excelStyles') || [];
+        this.adaptableApi.internalApi.forAllVisibleRowNodesDo((node, rowIndex) => {
+            var _a;
+            const rowParams = {
+                node,
+                data: node.data,
+                rowIndex,
+                api: agGridApi,
+                columnApi: null,
+                context: ((_a = agGridApi.__getContext) === null || _a === void 0 ? void 0 : _a.call(agGridApi)) || {},
+            };
+            const getRowStyleFn = agGridApi.getGridOption('getRowStyle');
+            const rowStyle = getRowStyleFn ? getRowStyleFn(rowParams) : {};
+            displayedColumns.forEach((column, columnIndex) => {
+                var _a, _b, _c;
+                const colDef = colDefs[columnIndex];
+                let cellClassParams;
+                const getLazyCellClassParams = () => {
+                    if (!cellClassParams) {
+                        cellClassParams = {
+                            colDef,
+                            node,
+                            column,
+                            data: node.data,
+                            value: this.adaptableApi.gridApi.getRawValueFromRowNode(node, column.getId()),
+                            rowIndex,
+                            api: agGridApi,
+                            columnApi: null,
+                            context: {},
+                        };
+                    }
+                    return cellClassParams;
+                };
+                const cellStyle = typeof colDef.cellStyle === 'function' ? colDef.cellStyle(getLazyCellClassParams()) : {};
+                const excelStyles = [];
+                // add user defined excel styles
+                let userColDefCellClass = this.adaptableApi.internalApi
+                    .getAdaptableInstance()
+                    .agGridColumnAdapter.getUserColDefProperty(column.getColId(), 'cellClass');
+                const userDefinedCellClass = typeof userColDefCellClass === 'function'
+                    ? userColDefCellClass(getLazyCellClassParams())
+                    : userColDefCellClass;
+                const userDefinedExcelStyle = userDefinedCellClass &&
+                    userExcelStyles.find((excelStyle) => {
+                        var _a;
+                        return typeof userDefinedCellClass === 'string'
+                            ? userDefinedCellClass === excelStyle.id
+                            : (_a = userDefinedCellClass === null || userDefinedCellClass === void 0 ? void 0 : userDefinedCellClass.includes) === null || _a === void 0 ? void 0 : _a.call(userDefinedCellClass, excelStyle.id);
+                    });
+                if (userDefinedExcelStyle) {
+                    excelStyles.push(userDefinedExcelStyle);
+                }
+                // add adaptable derived styles (format column etc.)
+                const adaptableStyle = Object.assign(Object.assign({}, rowStyle), Object.keys(cellStyle).reduce((result, key) => {
+                    if (cellStyle[key] !== null) {
+                        result[key] = cellStyle[key];
+                    }
+                    return result;
+                }, {}));
+                const sanitizedAdaptableStyle = sanitizeStyle(adaptableStyle);
+                if (Object.values(sanitizedAdaptableStyle).some((style) => style != null)) {
+                    excelStyles.push(this.convertCSSToExcelStyle(sanitizedAdaptableStyle));
+                }
+                const excelDataType = this.adaptableApi.exportApi.internalApi.getExcelDataType(colDef === null || colDef === void 0 ? void 0 : colDef.type);
+                const rawValue = this.adaptableApi.gridApi.getRawValueFromRowNode(node, column.getId());
+                // don't add the cell style if it has no adaptable custom styles
+                if (!excelStyles.length &&
+                    // if this is a formatted Date value, we still need to add the AG GRID specific type & numberFormat below
+                    !(excelDataType === 'DateTime' && isDateCellExportedAsFormattedValue)) {
+                    return;
+                }
+                const cellClassId = this.adaptableApi.internalApi
+                    .getAdaptableInstance()
+                    .agGridColumnAdapter.getExcelClassNameForCell(column.getId(), this.adaptableApi.internalApi
+                    .getAdaptableInstance()
+                    .getPrimaryKeyValueFromRowNode(node), userDefinedCellClass);
+                const finalCellExcelStyle = Object.assign({}, ...excelStyles);
+                if (excelDataType === 'DateTime' && isDateCellExportedAsFormattedValue) {
+                    let dateFormatPattern = this.adaptableApi.optionsApi.getExportOptions().exportDateFormat;
+                    const abColumn = getAdaptableColumnWithColumnId(column.getColId());
+                    if (!dateFormatPattern) {
+                        const mostRelevantFormatColumn = this.adaptableApi.formatColumnApi.internalApi.getMostRelevantFormatColumnForColumn(getFormatColumnsWithDisplayFormatForColumn(column.getColId()), abColumn, { node, value: rawValue });
+                        dateFormatPattern =
+                            ((_a = mostRelevantFormatColumn === null || mostRelevantFormatColumn === void 0 ? void 0 : mostRelevantFormatColumn.DisplayFormat) === null || _a === void 0 ? void 0 : _a.Formatter) === 'DateFormatter' &&
+                                ((_c = (_b = mostRelevantFormatColumn === null || mostRelevantFormatColumn === void 0 ? void 0 : mostRelevantFormatColumn.DisplayFormat) === null || _b === void 0 ? void 0 : _b.Options) === null || _c === void 0 ? void 0 : _c.Pattern);
+                    }
+                    if (dateFormatPattern) {
+                        const normalisedValue = this.adaptableApi.internalApi
+                            .getAdaptableInstance()
+                            .getNormalisedValueFromRawValue(rawValue, abColumn);
+                        if (normalisedValue) {
+                            // we have to pass the date in the ISO format to Excel
+                            // see https://www.ag-grid.com/javascript-data-grid/excel-export-data-types/#dates
+                            // we can NOT use Date.toISOString() because we don't want the timezone corrections to kick in
+                            const isoFormattedValue = DateFormatter(normalisedValue, {
+                                Pattern: `yyyy-MM-dd'T'HH:mm:ss.SSS`,
+                            });
+                            if (isoFormattedValue) {
+                                finalCellExcelStyle.dataType = 'DateTime';
+                                finalCellExcelStyle.numberFormat = { format: dateFormatPattern };
+                                // create a new cell key to ensure any user provided className does not interfere
+                                const cellKey = this.adaptableApi.internalApi
+                                    .getAdaptableInstance()
+                                    .agGridColumnAdapter.getExcelClassNameForCell(column.getColId(), this.adaptableApi.internalApi
+                                    .getAdaptableInstance()
+                                    .getPrimaryKeyValueFromRowNode(node));
+                                // we need to register so that later the cellProcessor will put the isoFormattedValue through (thus giving the formatting responsability to Excel)
+                                this.registerExcelStyleWithFormattedDate(cellKey, isoFormattedValue);
+                            }
+                        }
+                    }
+                }
+                this.registerExcelStyle(finalCellExcelStyle, cellClassId);
+            });
+        }, forAllVisibleRowNodesDoConfig);
+    }
+    convertCSSToExcelStyle(style) {
+        const getHexColor = (color) => {
+            const preparedColor = getVariableColor(color);
+            const t = tinycolor(preparedColor);
+            const a = t.getAlpha();
+            return tinycolor.mix(tinycolor('white'), t, a * 100).toHexString();
+        };
+        let result = {};
+        if (style.backgroundColor != null) {
+            result.interior = {
+                color: getHexColor(style.backgroundColor),
+                pattern: 'Solid',
+            };
+        }
+        if (style.borderColor != null) {
+            const excelBorder = {
+                color: style.borderColor,
+                lineStyle: 'Continuous',
+                weight: 1,
+            };
+            result.borders = {
+                borderBottom: excelBorder,
+                borderLeft: excelBorder,
+                borderRight: excelBorder,
+                borderTop: excelBorder,
+            };
+        }
+        if (style.textAlign) {
+            result.alignment = {
+                horizontal: StringExtensions.CapitaliseFirstLetter(style.textAlign),
+            };
+        }
+        if (style.color != null) {
+            if (!result.font) {
+                result.font = {};
+            }
+            result.font = {
+                color: getHexColor(style.color),
+            };
+        }
+        if (style.fontStyle === 'italic') {
+            if (!result.font) {
+                result.font = {};
+            }
+            result.font.italic = true;
+        }
+        if (style.fontWeight != null &&
+            (style.fontWeight === 'bold' || Number(style.fontWeight) >= 600)) {
+            if (!result.font) {
+                result.font = {};
+            }
+            result.font.bold = true;
+        }
+        if (style.fontSize != null) {
+            if (!result.font) {
+                result.font = {};
+            }
+            result.font.size = convertCSSAbsoluteFontSizeToPt(style.fontSize);
+        }
+        return result;
+    }
+    resetExcelStyleMemoization() {
+        this.excelStylesCache = {};
+        this.cellClassKey2excelStyleIdMap = {};
+        this.excelStylesWithFormattedDate = {};
+    }
+    registerExcelStyle(excelStyle, cellClassKey) {
+        const excelStyleKey = JSON.stringify(excelStyle);
+        if (!this.excelStylesCache[excelStyleKey]) {
+            const excelStyleId = createUuid();
+            const excelStyleWithId = Object.assign(Object.assign({}, excelStyle), { id: excelStyleId });
+            this.excelStylesCache[excelStyleKey] = excelStyleWithId;
+        }
+        this.cellClassKey2excelStyleIdMap[cellClassKey] = this.excelStylesCache[excelStyleKey].id;
+    }
+    registerExcelStyleWithFormattedDate(cellClassId, isoFormattedValue) {
+        this.excelStylesWithFormattedDate[cellClassId] = isoFormattedValue;
+    }
 }

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

@@ -0,0 +1,26 @@
+import { AdaptableApi, Layout } from '../../types';
+import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
+/**
+ * The logic is extracted here to make it easier to follow
+ */
+export declare class RowSummaryService {
+    private api;
+    cachedCellSummary: Map<string, AggregatedScalarLiveValue>;
+    previousRowSummaries: any;
+    previousLayout: Layout | null;
+    constructor(api: AdaptableApi);
+    onAdapterReady(): void;
+    rowSummariesSubscriptions(): void;
+    _throttleAcumulatedColumnsThatChanged: Set<string>;
+    throttledEvaluateRowSummary(reason?: {
+        columnIds: string[];
+    }): void;
+    /**
+     *
+     * @param colId optional to evaluate only one column
+     */
+    _throttledEvaluateRowSummary: import("lodash").DebouncedFunc<(reason?: {
+        columnIds: string[];
+    }) => void>;
+    private evaluateRowSummary;
+}

package/src/Utilities/Services/RowSummaryService.js

@@ -0,0 +1,155 @@
+import { isEqual } from 'lodash';
+import { ROW_SUMMARY_ROW_ID, WEIGHTED_AVERAGE_AGGREATED_FUNCTION, } from '../../PredefinedConfig/Common/RowSummary';
+import { SystemRowSummarySet } from '../../Redux/ActionsReducers/SystemRedux';
+import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
+import Helper from '../Helpers/Helper';
+import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
+import { isObjectEmpty } from '../Extensions/ObjectExtensions';
+import throttle from 'lodash/throttle';
+/**
+ * The logic is extracted here to make it easier to follow
+ */
+export class RowSummaryService {
+    constructor(api) {
+        this.api = api;
+        this.cachedCellSummary = new Map();
+        this._throttleAcumulatedColumnsThatChanged = new Set();
+        /**
+         *
+         * @param colId optional to evaluate only one column
+         */
+        this._throttledEvaluateRowSummary = throttle(this.evaluateRowSummary, 300);
+    }
+    onAdapterReady() {
+        this.rowSummariesSubscriptions();
+    }
+    rowSummariesSubscriptions() {
+        // return;
+        if (this.api.isDestroyed()) {
+            return;
+        }
+        // Currently not available for serverside model
+        if (!this.api.layoutApi.internalApi.getLayoutSupportedFeatures().RowSummaries) {
+            return;
+        }
+        this.throttledEvaluateRowSummary();
+        this.api.eventApi.on('AdaptableStateReloaded', () => {
+            this.throttledEvaluateRowSummary();
+        });
+        this.api.eventApi.on('GridDataChanged', (event) => {
+            this.throttledEvaluateRowSummary();
+        });
+        this.api.eventApi.on('CellChanged', (event) => {
+            const columnId = event.cellChange.column.columnId;
+            this.throttledEvaluateRowSummary({
+                columnIds: [columnId],
+            });
+        });
+        this.api.eventApi.on('LayoutChanged', (event) => {
+            // exclude filter events, those are handled in another event
+            if (event.actionName.includes('FILTER')) {
+                return;
+            }
+            setTimeout(() => {
+                // the timeout is added so the grid has time to repond to the layout changed
+                this.throttledEvaluateRowSummary();
+            }, 16);
+        });
+        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
+            this.throttledEvaluateRowSummary();
+        });
+        adaptable._on('FirstDataRendered', () => {
+            this.throttledEvaluateRowSummary();
+        });
+    }
+    throttledEvaluateRowSummary(reason) {
+        if (reason) {
+            reason.columnIds.forEach((col) => this._throttleAcumulatedColumnsThatChanged.add(col));
+        }
+        this._throttledEvaluateRowSummary(reason);
+    }
+    evaluateRowSummary(reason) {
+        var _a;
+        if (this._throttleAcumulatedColumnsThatChanged.size > 0) {
+            const columnIds = Array.from(this._throttleAcumulatedColumnsThatChanged.values());
+            reason = {
+                columnIds,
+            };
+            this._throttleAcumulatedColumnsThatChanged.clear();
+        }
+        if (this.api.isDestroyed()) {
+            return;
+        }
+        const currentLayout = this.api.layoutApi.getCurrentLayout();
+        let previousLayout = this.previousLayout;
+        // it is added here to be sure it is saved
+        this.previousLayout = currentLayout;
+        /**
+         * 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)) {
+            return;
+        }
+        const rowSummaries = (_a = this.api.layoutApi.getCurrentLayout().RowSummaries) !== null && _a !== void 0 ? _a : [];
+        const rowSummariesResults = rowSummaries.map(({ ColumnsMap, Position }) => {
+            return {
+                Position,
+                RowData: Object.entries(ColumnsMap !== null && ColumnsMap !== void 0 ? ColumnsMap : {}).reduce((acc, [columnId, expression]) => {
+                    const key = `${columnId}-${expression}`;
+                    let expressionLiveValue = this.cachedCellSummary.get(key);
+                    if (expressionLiveValue) {
+                        if (!reason) {
+                            // refresh all of them
+                            expressionLiveValue.refresh();
+                        }
+                        else if ('columnIds' in reason && reason.columnIds.includes(columnId)) {
+                            expressionLiveValue.refresh();
+                        }
+                    }
+                    if (!expressionLiveValue) {
+                        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;
+                                if (weight) {
+                                    aggregatedScalarExpression = `AVG([${columnId}], WEIGHT([${weight}]))`;
+                                }
+                            }
+                            expressionLiveValue = new AggregatedScalarLiveValue({
+                                aggregatedScalarExpression,
+                            }, ModuleConstants.LayoutModuleId, this.api, () => {
+                                return this.api.gridApi.getVisibleRowNodes();
+                            });
+                        }
+                        catch (e) {
+                            this.api.logError('Error evaluating row summary', e);
+                        }
+                        this.cachedCellSummary.set(key, expressionLiveValue);
+                    }
+                    let value = null;
+                    if (expressionLiveValue) {
+                        value = expressionLiveValue.getGlobalAggregatedValue();
+                        if (typeof value === 'number' && !isNaN(value)) {
+                            value = Helper.roundNumber(value, 2);
+                        }
+                    }
+                    acc[columnId] = value;
+                    return acc;
+                }, {
+                    [ROW_SUMMARY_ROW_ID]: true,
+                }),
+            };
+        });
+        if (this.previousRowSummaries && isEqual(rowSummariesResults, this.previousRowSummaries)) {
+            return;
+        }
+        this.api.internalApi.dispatchReduxAction(SystemRowSummarySet(rowSummariesResults));
+        this.previousRowSummaries = rowSummariesResults;
+    }
+}

package/src/Utilities/Services/ValidationService.js

@@ -15,7 +15,7 @@ export class ValidationService {
         }
         let editingRules = this.adaptableApi.alertApi.internalApi
             .getAlertDefinitionsWithPreventEdit()
-            .filter((v) => this.adaptableApi.scopeApi.isColumnInScope(cellDataChangedInfo.column, v.Scope));
+            .filter((v) => this.adaptableApi.columnScopeApi.isColumnInScope(cellDataChangedInfo.column, v.Scope));
         let failedValidations = [];
         if (ArrayExtensions.IsNotEmpty(editingRules)) {
             editingRules.forEach((alertDefinition) => {
@@ -127,7 +127,7 @@ export class ValidationService {
     }
     createValidationDescription(alertDefinition) {
         var _a, _b;
-        return (this.adaptableApi.scopeApi.getScopeDescription(alertDefinition.Scope) +
+        return (this.adaptableApi.columnScopeApi.getScopeDescription(alertDefinition.Scope) +
             ' ' +
             ((_b = (_a = alertDefinition.Rule) === null || _a === void 0 ? void 0 : _a.Predicates) === null || _b === void 0 ? void 0 : _b.map((predicate) => this.adaptableApi.predicateApi.predicateToString(predicate)).join(' AND ')));
     }

package/src/Utilities/adaptableQlUtils.d.ts

@@ -0,0 +1,2 @@
+import { AdaptableColumnDataType, ExpressionFunctionInputType } from '../types';
+export declare const mapColumnDataTypeToExpressionFunctionType: (dataType: AdaptableColumnDataType) => ExpressionFunctionInputType;

package/src/Utilities/adaptableQlUtils.js

@@ -0,0 +1,14 @@
+export const mapColumnDataTypeToExpressionFunctionType = (dataType) => {
+    if (dataType === 'Number') {
+        return 'number';
+    }
+    if (dataType === 'Boolean') {
+        return 'boolean';
+    }
+    if (dataType === 'String') {
+        return 'text';
+    }
+    if (dataType === 'Date') {
+        return 'date';
+    }
+};