devextreme 22.2.5 → 22.2.6

package/cjs/__internal/grids/data_grid/summary/module.js

@@ -0,0 +1,810 @@
+/**
+ * DevExtreme (cjs/__internal/grids/data_grid/summary/module.js)
+ * Version: 22.2.6
+ * Build date: Tue Apr 18 2023
+ *
+ * Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+ * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
+ */
+"use strict";
+var __importDefault = this && this.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : {
+        default: mod
+    }
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.FooterView = exports.renderSummaryCell = void 0;
+var renderer_1 = __importDefault(require("../../../../core/renderer"));
+var common_1 = require("../../../../core/utils/common");
+var type_1 = require("../../../../core/utils/type");
+var iterator_1 = require("../../../../core/utils/iterator");
+var extend_1 = require("../../../../core/utils/extend");
+var data_1 = require("../../../../core/utils/data");
+var message_1 = __importDefault(require("../../../../localization/message"));
+var ui_grid_core_columns_view_1 = require("../../../../ui/grid_core/ui.grid_core.columns_view");
+var query_1 = __importDefault(require("../../../../data/query"));
+var store_helper_1 = __importDefault(require("../../../../data/store_helper"));
+var utils_1 = require("../../../../data/utils");
+var ui_errors_1 = __importDefault(require("../../../../ui/widget/ui.errors"));
+var module_aggregate_calculator_1 = __importDefault(require("../module_aggregate_calculator"));
+var module_data_source_adapter_1 = __importDefault(require("../module_data_source_adapter"));
+var module_core_1 = __importDefault(require("../module_core"));
+var DATAGRID_TOTAL_FOOTER_CLASS = "dx-datagrid-total-footer";
+var DATAGRID_SUMMARY_ITEM_CLASS = "dx-datagrid-summary-item";
+var DATAGRID_TEXT_CONTENT_CLASS = "dx-datagrid-text-content";
+var DATAGRID_GROUP_FOOTER_CLASS = "dx-datagrid-group-footer";
+var DATAGRID_GROUP_TEXT_CONTENT_CLASS = "dx-datagrid-group-text-content";
+var DATAGRID_NOWRAP_CLASS = "dx-datagrid-nowrap";
+var DATAGRID_FOOTER_ROW_CLASS = "dx-footer-row";
+var DATAGRID_GROUP_FOOTER_ROW_TYPE = "groupFooter";
+var DATAGRID_TOTAL_FOOTER_ROW_TYPE = "totalFooter";
+var renderSummaryCell = function(cell, options) {
+    var $cell = renderer_1.default(cell);
+    var column = options.column;
+    var summaryItems = options.summaryItems;
+    var $summaryItems = [];
+    if (!column.command && summaryItems) {
+        for (var i = 0; i < summaryItems.length; i++) {
+            var summaryItem = summaryItems[i];
+            $summaryItems.push(renderer_1.default("<div>").css("textAlign", summaryItem.alignment || column.alignment).addClass(DATAGRID_SUMMARY_ITEM_CLASS).addClass(DATAGRID_TEXT_CONTENT_CLASS).addClass(summaryItem.cssClass).toggleClass(DATAGRID_GROUP_TEXT_CONTENT_CLASS, "group" === options.rowType).text(module_core_1.default.getSummaryText(summaryItem, options.summaryTexts)))
+        }
+        $cell.append($summaryItems)
+    }
+};
+exports.renderSummaryCell = renderSummaryCell;
+var getSummaryCellOptions = function(that, options) {
+    var summaryTexts = that.option("summary.texts") || {};
+    return {
+        totalItem: options.row,
+        summaryItems: options.row.summaryCells[options.columnIndex],
+        summaryTexts: summaryTexts
+    }
+};
+var getGroupAggregates = function(data) {
+    return data.summary || data.aggregates || []
+};
+var recalculateWhileEditing = function(that) {
+    return that.option("summary.recalculateWhileEditing")
+};
+exports.FooterView = ui_grid_core_columns_view_1.ColumnsView.inherit({
+    _getRows: function() {
+        return this._dataController.footerItems()
+    },
+    _getCellOptions: function(options) {
+        return extend_1.extend(this.callBase(options), getSummaryCellOptions(this, options))
+    },
+    _renderCellContent: function($cell, options) {
+        exports.renderSummaryCell($cell, options);
+        this.callBase.apply(this, arguments)
+    },
+    _renderCore: function(change) {
+        var needUpdateScrollLeft = false;
+        var totalItem = this._dataController.footerItems()[0];
+        if (!change || !change.columnIndices) {
+            this.element().empty().addClass(DATAGRID_TOTAL_FOOTER_CLASS).toggleClass(DATAGRID_NOWRAP_CLASS, !this.option("wordWrapEnabled"));
+            needUpdateScrollLeft = true
+        }
+        if (totalItem && totalItem.summaryCells && totalItem.summaryCells.length) {
+            this._updateContent(this._renderTable({
+                change: change
+            }), change);
+            needUpdateScrollLeft && this._updateScrollLeftPosition()
+        }
+    },
+    _updateContent: function($newTable, change) {
+        var _this = this;
+        if (change && "update" === change.changeType && change.columnIndices) {
+            return this.waitAsyncTemplates().done((function() {
+                var $row = _this.getTableElement().find(".dx-row");
+                var $newRow = $newTable.find(".dx-row");
+                _this._updateCells($row, $newRow, change.columnIndices[0])
+            }))
+        }
+        return this.callBase.apply(this, arguments)
+    },
+    _rowClick: function(e) {
+        var item = this._dataController.footerItems()[e.rowIndex] || {};
+        this.executeAction("onRowClick", extend_1.extend({}, e, item))
+    },
+    _columnOptionChanged: function(e) {
+        var optionNames = e.optionNames;
+        if (e.changeTypes.grouping) {
+            return
+        }
+        if (optionNames.width || optionNames.visibleWidth) {
+            this.callBase(e)
+        }
+    },
+    _handleDataChanged: function(e) {
+        var changeType = e.changeType;
+        if ("update" === e.changeType && e.repaintChangesOnly) {
+            if (!e.totalColumnIndices) {
+                this.render()
+            } else if (e.totalColumnIndices.length) {
+                this.render(null, {
+                    changeType: "update",
+                    columnIndices: [e.totalColumnIndices]
+                })
+            }
+        } else if ("refresh" === changeType || "append" === changeType || "prepend" === changeType) {
+            this.render()
+        }
+    },
+    _createRow: function(row) {
+        var $row = this.callBase.apply(this, arguments);
+        if (row.rowType === DATAGRID_TOTAL_FOOTER_ROW_TYPE) {
+            $row.addClass(DATAGRID_FOOTER_ROW_CLASS)
+        }
+        return $row
+    },
+    getHeight: function() {
+        return this.getElementHeight()
+    },
+    isVisible: function() {
+        return !!this._dataController.footerItems().length
+    }
+});
+var SummaryDataSourceAdapterExtender = {
+    init: function() {
+        this.callBase.apply(this, arguments);
+        this._totalAggregates = [];
+        this._summaryGetter = common_1.noop
+    },
+    summaryGetter: function(summaryGetter) {
+        if (!arguments.length) {
+            return this._summaryGetter
+        }
+        if (type_1.isFunction(summaryGetter)) {
+            this._summaryGetter = summaryGetter
+        }
+    },
+    summary: function(summary) {
+        if (!arguments.length) {
+            return this._summaryGetter()
+        }
+        this._summaryGetter = function() {
+            return summary
+        }
+    },
+    totalAggregates: function() {
+        return this._totalAggregates
+    },
+    isLastLevelGroupItemsPagingLocal: function() {
+        var summary = this.summary();
+        var sortByGroupsInfo = summary && summary.sortByGroups();
+        return sortByGroupsInfo && sortByGroupsInfo.length
+    },
+    sortLastLevelGroupItems: function(items, groups, paths) {
+        var groupedItems = store_helper_1.default.multiLevelGroup(query_1.default(items), groups).toArray();
+        var result = [];
+        paths.forEach((function(path) {
+            ! function forEachGroup(groups, groupCount, callback, path) {
+                path = path || [];
+                for (var i = 0; i < groups.length; i++) {
+                    path.push(groups[i].key);
+                    if (1 === groupCount) {
+                        callback(path, groups[i].items)
+                    } else {
+                        forEachGroup(groups[i].items, groupCount - 1, callback, path)
+                    }
+                    path.pop()
+                }
+            }(groupedItems, groups.length, (function(itemsPath, items) {
+                if (path.toString() === itemsPath.toString()) {
+                    result = result.concat(items)
+                }
+            }))
+        }));
+        return result
+    }
+};
+var SummaryDataSourceAdapterClientExtender = function() {
+    var applyAddedData = function(data, insertedData, groupLevel) {
+        if (groupLevel) {
+            return applyAddedData(data, insertedData.map((function(item) {
+                return {
+                    items: [item]
+                }
+            }), groupLevel - 1))
+        }
+        return data.concat(insertedData)
+    };
+    var applyRemovedData = function(data, removedData, groupLevel) {
+        if (groupLevel) {
+            return data.map((function(data) {
+                var updatedData = {};
+                var updatedItems = applyRemovedData(data.items || [], removedData, groupLevel - 1);
+                Object.defineProperty(updatedData, "aggregates", {
+                    get: function() {
+                        return data.aggregates
+                    },
+                    set: function(value) {
+                        data.aggregates = value
+                    }
+                });
+                return extend_1.extend(updatedData, data, {
+                    items: updatedItems
+                })
+            }))
+        }
+        return data.filter((function(data) {
+            return removedData.indexOf(data) < 0
+        }))
+    };
+    var calculateAggregates = function(that, summary, data, groupLevel) {
+        var calculator;
+        if (recalculateWhileEditing(that)) {
+            var editingController = that.getController("editing");
+            if (editingController) {
+                var insertedData = editingController.getInsertedData();
+                if (insertedData.length) {
+                    data = applyAddedData(data, insertedData, groupLevel)
+                }
+                var removedData = editingController.getRemovedData();
+                if (removedData.length) {
+                    data = applyRemovedData(data, removedData, groupLevel)
+                }
+            }
+        }
+        if (summary) {
+            calculator = new module_aggregate_calculator_1.default({
+                totalAggregates: summary.totalAggregates,
+                groupAggregates: summary.groupAggregates,
+                data: data,
+                groupLevel: groupLevel
+            });
+            calculator.calculate()
+        }
+        return calculator ? calculator.totalAggregates() : []
+    };
+    var sortGroupsBySummaryCore = function(items, groups, sortByGroups) {
+        if (!items || !groups.length) {
+            return items
+        }
+        var group = groups[0];
+        var sorts = sortByGroups[0];
+        var query;
+        if (group && sorts && sorts.length) {
+            query = query_1.default(items);
+            iterator_1.each(sorts, (function(index) {
+                if (0 === index) {
+                    query = query.sortBy(this.selector, this.desc)
+                } else {
+                    query = query.thenBy(this.selector, this.desc)
+                }
+            }));
+            query.enumerate().done((function(sortedItems) {
+                items = sortedItems
+            }))
+        }
+        groups = groups.slice(1);
+        sortByGroups = sortByGroups.slice(1);
+        if (groups.length && sortByGroups.length) {
+            iterator_1.each(items, (function() {
+                this.items = sortGroupsBySummaryCore(this.items, groups, sortByGroups)
+            }))
+        }
+        return items
+    };
+    var sortGroupsBySummary = function(data, group, summary) {
+        var sortByGroups = summary && summary.sortByGroups && summary.sortByGroups();
+        if (sortByGroups && sortByGroups.length) {
+            return sortGroupsBySummaryCore(data, group, sortByGroups)
+        }
+        return data
+    };
+    return {
+        _customizeRemoteOperations: function(options) {
+            var summary = this.summary();
+            if (summary) {
+                if (options.remoteOperations.summary) {
+                    if (!options.isCustomLoading || options.storeLoadOptions.isLoadingAll) {
+                        if (options.storeLoadOptions.group) {
+                            if (options.remoteOperations.grouping) {
+                                options.storeLoadOptions.groupSummary = summary.groupAggregates
+                            } else if (summary.groupAggregates.length) {
+                                options.remoteOperations.paging = false
+                            }
+                        }
+                        options.storeLoadOptions.totalSummary = summary.totalAggregates
+                    }
+                } else if (summary.totalAggregates.length || summary.groupAggregates.length && options.storeLoadOptions.group) {
+                    options.remoteOperations.paging = false
+                }
+            }
+            this.callBase.apply(this, arguments);
+            var cachedExtra = options.cachedData.extra;
+            if (cachedExtra && cachedExtra.summary && !options.isCustomLoading) {
+                options.storeLoadOptions.totalSummary = void 0
+            }
+        },
+        _handleDataLoadedCore: function(options) {
+            var _a, _b;
+            var groups = utils_1.normalizeSortingInfo(options.storeLoadOptions.group || options.loadOptions.group || []);
+            var remoteOperations = options.remoteOperations || {};
+            var summary = this.summaryGetter()(remoteOperations);
+            if (!options.isCustomLoading || options.storeLoadOptions.isLoadingAll) {
+                if (remoteOperations.summary) {
+                    if (!remoteOperations.paging && groups.length && summary) {
+                        if (!remoteOperations.grouping) {
+                            calculateAggregates(this, {
+                                groupAggregates: summary.groupAggregates
+                            }, options.data, groups.length)
+                        }
+                        options.data = sortGroupsBySummary(options.data, groups, summary)
+                    }
+                } else if (!remoteOperations.paging && summary) {
+                    var operationTypes_1 = options.operationTypes || {};
+                    var hasOperations = Object.keys(operationTypes_1).some((function(type) {
+                        return operationTypes_1[type]
+                    }));
+                    if (!hasOperations || !(null === (_b = null === (_a = options.cachedData) || void 0 === _a ? void 0 : _a.extra) || void 0 === _b ? void 0 : _b.summary) || groups.length && summary.groupAggregates.length) {
+                        var totalAggregates = calculateAggregates(this, summary, options.data, groups.length);
+                        options.extra = type_1.isPlainObject(options.extra) ? options.extra : {};
+                        options.extra.summary = totalAggregates;
+                        if (options.cachedData) {
+                            options.cachedData.extra = options.extra
+                        }
+                    }
+                    options.data = sortGroupsBySummary(options.data, groups, summary)
+                }
+            }
+            if (!options.isCustomLoading) {
+                this._totalAggregates = options.extra && options.extra.summary || this._totalAggregates
+            }
+            this.callBase(options)
+        }
+    }
+}();
+module_data_source_adapter_1.default.extend(SummaryDataSourceAdapterExtender);
+module_data_source_adapter_1.default.extend(SummaryDataSourceAdapterClientExtender);
+module_core_1.default.registerModule("summary", {
+    defaultOptions: function() {
+        return {
+            summary: {
+                groupItems: void 0,
+                totalItems: void 0,
+                calculateCustomSummary: void 0,
+                skipEmptyValues: true,
+                recalculateWhileEditing: false,
+                texts: {
+                    sum: message_1.default.format("dxDataGrid-summarySum"),
+                    sumOtherColumn: message_1.default.format("dxDataGrid-summarySumOtherColumn"),
+                    min: message_1.default.format("dxDataGrid-summaryMin"),
+                    minOtherColumn: message_1.default.format("dxDataGrid-summaryMinOtherColumn"),
+                    max: message_1.default.format("dxDataGrid-summaryMax"),
+                    maxOtherColumn: message_1.default.format("dxDataGrid-summaryMaxOtherColumn"),
+                    avg: message_1.default.format("dxDataGrid-summaryAvg"),
+                    avgOtherColumn: message_1.default.format("dxDataGrid-summaryAvgOtherColumn"),
+                    count: message_1.default.format("dxDataGrid-summaryCount")
+                }
+            },
+            sortByGroupSummaryInfo: void 0
+        }
+    },
+    views: {
+        footerView: exports.FooterView
+    },
+    extenders: {
+        controllers: {
+            data: {
+                _isDataColumn: function(column) {
+                    return column && (!type_1.isDefined(column.groupIndex) || column.showWhenGrouped)
+                },
+                _isGroupFooterVisible: function() {
+                    var groupItems = this.option("summary.groupItems") || [];
+                    for (var i = 0; i < groupItems.length; i++) {
+                        var groupItem = groupItems[i];
+                        var column = this._columnsController.columnOption(groupItem.showInColumn || groupItem.column);
+                        if (groupItem.showInGroupFooter && this._isDataColumn(column)) {
+                            return true
+                        }
+                    }
+                    return false
+                },
+                _processGroupItems: function(items, groupCount, options) {
+                    var data = options && options.data;
+                    var result = this.callBase.apply(this, arguments);
+                    if (options) {
+                        if (void 0 === options.isGroupFooterVisible) {
+                            options.isGroupFooterVisible = this._isGroupFooterVisible()
+                        }
+                        if (data && data.items && options.isGroupFooterVisible && (options.collectContinuationItems || !data.isContinuationOnNextPage)) {
+                            result.push({
+                                rowType: DATAGRID_GROUP_FOOTER_ROW_TYPE,
+                                key: options.path.slice(),
+                                data: data,
+                                groupIndex: options.path.length - 1,
+                                values: []
+                            })
+                        }
+                    }
+                    return result
+                },
+                _processGroupItem: function(groupItem, options) {
+                    var that = this;
+                    if (!options.summaryGroupItems) {
+                        options.summaryGroupItems = that.option("summary.groupItems") || []
+                    }
+                    if ("group" === groupItem.rowType) {
+                        var groupColumnIndex_1 = -1;
+                        var afterGroupColumnIndex_1 = -1;
+                        iterator_1.each(options.visibleColumns, (function(visibleIndex) {
+                            var prevColumn = options.visibleColumns[visibleIndex - 1];
+                            if (groupItem.groupIndex === this.groupIndex) {
+                                groupColumnIndex_1 = this.index
+                            }
+                            if (visibleIndex > 0 && "expand" === prevColumn.command && "expand" !== this.command) {
+                                afterGroupColumnIndex_1 = this.index
+                            }
+                        }));
+                        groupItem.summaryCells = this._calculateSummaryCells(options.summaryGroupItems, getGroupAggregates(groupItem.data), options.visibleColumns, (function(summaryItem, column) {
+                            if (summaryItem.showInGroupFooter) {
+                                return -1
+                            }
+                            if (summaryItem.alignByColumn && column && !type_1.isDefined(column.groupIndex) && column.index !== afterGroupColumnIndex_1) {
+                                return column.index
+                            }
+                            return groupColumnIndex_1
+                        }), true)
+                    }
+                    if (groupItem.rowType === DATAGRID_GROUP_FOOTER_ROW_TYPE) {
+                        groupItem.summaryCells = this._calculateSummaryCells(options.summaryGroupItems, getGroupAggregates(groupItem.data), options.visibleColumns, (function(summaryItem, column) {
+                            return summaryItem.showInGroupFooter && that._isDataColumn(column) ? column.index : -1
+                        }))
+                    }
+                    return groupItem
+                },
+                _calculateSummaryCells: function(summaryItems, aggregates, visibleColumns, calculateTargetColumnIndex, isGroupRow) {
+                    var that = this;
+                    var summaryCells = [];
+                    var summaryCellsByColumns = {};
+                    iterator_1.each(summaryItems, (function(summaryIndex, summaryItem) {
+                        var column = that._columnsController.columnOption(summaryItem.column);
+                        var showInColumn = summaryItem.showInColumn && that._columnsController.columnOption(summaryItem.showInColumn) || column;
+                        var columnIndex = calculateTargetColumnIndex(summaryItem, showInColumn);
+                        if (columnIndex >= 0) {
+                            if (!summaryCellsByColumns[columnIndex]) {
+                                summaryCellsByColumns[columnIndex] = []
+                            }
+                            var aggregate = aggregates[summaryIndex];
+                            if (aggregate === aggregate) {
+                                var valueFormat = void 0;
+                                if (type_1.isDefined(summaryItem.valueFormat)) {
+                                    valueFormat = summaryItem.valueFormat
+                                } else if ("count" !== summaryItem.summaryType) {
+                                    valueFormat = module_core_1.default.getFormatByDataType(column && column.dataType)
+                                }
+                                summaryCellsByColumns[columnIndex].push(extend_1.extend({}, summaryItem, {
+                                    value: type_1.isString(aggregate) && column && column.deserializeValue ? column.deserializeValue(aggregate) : aggregate,
+                                    valueFormat: valueFormat,
+                                    columnCaption: column && column.index !== columnIndex ? column.caption : void 0
+                                }))
+                            }
+                        }
+                    }));
+                    if (!type_1.isEmptyObject(summaryCellsByColumns)) {
+                        visibleColumns.forEach((function(column, visibleIndex) {
+                            var prevColumn = visibleColumns[visibleIndex - 1];
+                            var columnIndex = isGroupRow && ("expand" === (null === prevColumn || void 0 === prevColumn ? void 0 : prevColumn.command) || "expand" === column.command) ? null === prevColumn || void 0 === prevColumn ? void 0 : prevColumn.index : column.index;
+                            summaryCells.push(summaryCellsByColumns[columnIndex] || [])
+                        }))
+                    }
+                    return summaryCells
+                },
+                _getSummaryCells: function(summaryTotalItems, totalAggregates) {
+                    var that = this;
+                    var columnsController = that._columnsController;
+                    return that._calculateSummaryCells(summaryTotalItems, totalAggregates, columnsController.getVisibleColumns(), (function(summaryItem, column) {
+                        return that._isDataColumn(column) ? column.index : -1
+                    }))
+                },
+                _updateItemsCore: function(change) {
+                    var summaryCells;
+                    var dataSource = this._dataSource;
+                    var footerItems = this._footerItems;
+                    var oldSummaryCells = footerItems && footerItems[0] && footerItems[0].summaryCells;
+                    var summaryTotalItems = this.option("summary.totalItems");
+                    this._footerItems = [];
+                    if (dataSource && summaryTotalItems && summaryTotalItems.length) {
+                        var totalAggregates = dataSource.totalAggregates();
+                        summaryCells = this._getSummaryCells(summaryTotalItems, totalAggregates);
+                        if (change && change.repaintChangesOnly && oldSummaryCells) {
+                            change.totalColumnIndices = summaryCells.map((function(summaryCell, index) {
+                                if (JSON.stringify(summaryCell) !== JSON.stringify(oldSummaryCells[index])) {
+                                    return index
+                                }
+                                return -1
+                            })).filter((function(index) {
+                                return index >= 0
+                            }))
+                        }
+                        if (summaryCells.length) {
+                            this._footerItems.push({
+                                rowType: DATAGRID_TOTAL_FOOTER_ROW_TYPE,
+                                summaryCells: summaryCells
+                            })
+                        }
+                    }
+                    this.callBase(change)
+                },
+                _prepareUnsavedDataSelector: function(selector) {
+                    if (recalculateWhileEditing(this)) {
+                        var editingController_1 = this.getController("editing");
+                        if (editingController_1) {
+                            return function(data) {
+                                data = editingController_1.getUpdatedData(data);
+                                return selector(data)
+                            }
+                        }
+                    }
+                    return selector
+                },
+                _prepareAggregateSelector: function(selector, aggregator) {
+                    selector = this._prepareUnsavedDataSelector(selector);
+                    if ("avg" === aggregator || "sum" === aggregator) {
+                        return function(data) {
+                            var value = selector(data);
+                            return type_1.isDefined(value) ? Number(value) : value
+                        }
+                    }
+                    return selector
+                },
+                _getAggregates: function(summaryItems, remoteOperations) {
+                    var that = this;
+                    var columnsController = that.getController("columns");
+                    var calculateCustomSummary = that.option("summary.calculateCustomSummary");
+                    var commonSkipEmptyValues = that.option("summary.skipEmptyValues");
+                    return iterator_1.map(summaryItems || [], (function(summaryItem) {
+                        var column = columnsController.columnOption(summaryItem.column);
+                        var calculateCellValue = column && column.calculateCellValue ? column.calculateCellValue.bind(column) : data_1.compileGetter(column ? column.dataField : summaryItem.column);
+                        var aggregator = summaryItem.summaryType || "count";
+                        var skipEmptyValues = type_1.isDefined(summaryItem.skipEmptyValues) ? summaryItem.skipEmptyValues : commonSkipEmptyValues;
+                        if (remoteOperations) {
+                            return {
+                                selector: summaryItem.column,
+                                summaryType: aggregator
+                            }
+                        }
+                        var selector = that._prepareAggregateSelector(calculateCellValue, aggregator);
+                        if ("custom" === aggregator) {
+                            if (!calculateCustomSummary) {
+                                ui_errors_1.default.log("E1026");
+                                calculateCustomSummary = function() {}
+                            }
+                            var options_1 = {
+                                component: that.component,
+                                name: summaryItem.name
+                            };
+                            calculateCustomSummary(options_1);
+                            options_1.summaryProcess = "calculate";
+                            aggregator = {
+                                seed: function(groupIndex) {
+                                    options_1.summaryProcess = "start";
+                                    options_1.totalValue = void 0;
+                                    options_1.groupIndex = groupIndex;
+                                    delete options_1.value;
+                                    calculateCustomSummary(options_1);
+                                    return options_1.totalValue
+                                },
+                                step: function(totalValue, value) {
+                                    options_1.summaryProcess = "calculate";
+                                    options_1.totalValue = totalValue;
+                                    options_1.value = value;
+                                    calculateCustomSummary(options_1);
+                                    return options_1.totalValue
+                                },
+                                finalize: function(totalValue) {
+                                    options_1.summaryProcess = "finalize";
+                                    options_1.totalValue = totalValue;
+                                    delete options_1.value;
+                                    calculateCustomSummary(options_1);
+                                    return options_1.totalValue
+                                }
+                            }
+                        }
+                        return {
+                            selector: selector,
+                            aggregator: aggregator,
+                            skipEmptyValues: skipEmptyValues
+                        }
+                    }))
+                },
+                _addSortInfo: function(sortByGroups, groupColumn, selector, sortOrder) {
+                    if (groupColumn) {
+                        var groupIndex = groupColumn.groupIndex;
+                        sortOrder = sortOrder || groupColumn.sortOrder;
+                        if (type_1.isDefined(groupIndex)) {
+                            sortByGroups[groupIndex] = sortByGroups[groupIndex] || [];
+                            sortByGroups[groupIndex].push({
+                                selector: selector,
+                                desc: "desc" === sortOrder
+                            })
+                        }
+                    }
+                },
+                _findSummaryItem: function(summaryItems, name) {
+                    var summaryItemIndex = -1;
+                    if (type_1.isDefined(name)) {
+                        iterator_1.each(summaryItems || [], (function(index) {
+                            if (this.name === name || index === name || this.summaryType === name || this.column === name || (summaryItem = this, summaryType = summaryItem.summaryType, column = summaryItem.column, summaryType && column && summaryType + "_" + column) === name) {
+                                summaryItemIndex = index;
+                                return false
+                            }
+                            var summaryItem, summaryType, column
+                        }))
+                    }
+                    return summaryItemIndex
+                },
+                _getSummarySortByGroups: function(sortByGroupSummaryInfo, groupSummaryItems) {
+                    var that = this;
+                    var columnsController = that._columnsController;
+                    var groupColumns = columnsController.getGroupColumns();
+                    var sortByGroups = [];
+                    if (!groupSummaryItems || !groupSummaryItems.length) {
+                        return
+                    }
+                    iterator_1.each(sortByGroupSummaryInfo || [], (function() {
+                        var sortOrder = this.sortOrder;
+                        var groupColumn = this.groupColumn;
+                        var summaryItemIndex = that._findSummaryItem(groupSummaryItems, this.summaryItem);
+                        if (summaryItemIndex < 0) {
+                            return
+                        }
+                        var selector = function(data) {
+                            return getGroupAggregates(data)[summaryItemIndex]
+                        };
+                        if (type_1.isDefined(groupColumn)) {
+                            groupColumn = columnsController.columnOption(groupColumn);
+                            that._addSortInfo(sortByGroups, groupColumn, selector, sortOrder)
+                        } else {
+                            iterator_1.each(groupColumns, (function(groupIndex, groupColumn) {
+                                that._addSortInfo(sortByGroups, groupColumn, selector, sortOrder)
+                            }))
+                        }
+                    }));
+                    return sortByGroups
+                },
+                _createDataSourceAdapterCore: function(dataSource, remoteOperations) {
+                    var that = this;
+                    var dataSourceAdapter = this.callBase(dataSource, remoteOperations);
+                    dataSourceAdapter.summaryGetter((function(currentRemoteOperations) {
+                        return that._getSummaryOptions(currentRemoteOperations || remoteOperations)
+                    }));
+                    return dataSourceAdapter
+                },
+                _getSummaryOptions: function(remoteOperations) {
+                    var that = this;
+                    var groupSummaryItems = that.option("summary.groupItems");
+                    var totalSummaryItems = that.option("summary.totalItems");
+                    var sortByGroupSummaryInfo = that.option("sortByGroupSummaryInfo");
+                    var groupAggregates = that._getAggregates(groupSummaryItems, remoteOperations && remoteOperations.grouping && remoteOperations.summary);
+                    var totalAggregates = that._getAggregates(totalSummaryItems, remoteOperations && remoteOperations.summary);
+                    if (groupAggregates.length || totalAggregates.length) {
+                        return {
+                            groupAggregates: groupAggregates,
+                            totalAggregates: totalAggregates,
+                            sortByGroups: function() {
+                                return that._getSummarySortByGroups(sortByGroupSummaryInfo, groupSummaryItems)
+                            }
+                        }
+                    }
+                },
+                publicMethods: function() {
+                    var methods = this.callBase();
+                    methods.push("getTotalSummaryValue");
+                    return methods
+                },
+                getTotalSummaryValue: function(summaryItemName) {
+                    var summaryItemIndex = this._findSummaryItem(this.option("summary.totalItems"), summaryItemName);
+                    var aggregates = this._dataSource.totalAggregates();
+                    if (aggregates.length && summaryItemIndex > -1) {
+                        return aggregates[summaryItemIndex]
+                    }
+                },
+                optionChanged: function(args) {
+                    if ("summary" === args.name || "sortByGroupSummaryInfo" === args.name) {
+                        args.name = "dataSource"
+                    }
+                    this.callBase(args)
+                },
+                init: function() {
+                    this._footerItems = [];
+                    this.callBase()
+                },
+                footerItems: function() {
+                    return this._footerItems
+                }
+            },
+            editing: {
+                _refreshSummary: function() {
+                    if (recalculateWhileEditing(this) && !this.isSaving()) {
+                        this._dataController.refresh({
+                            load: true,
+                            changesOnly: true
+                        })
+                    }
+                },
+                _addChange: function(params) {
+                    var result = this.callBase.apply(this, arguments);
+                    if (params.type) {
+                        this._refreshSummary()
+                    }
+                    return result
+                },
+                _removeChange: function() {
+                    var result = this.callBase.apply(this, arguments);
+                    this._refreshSummary();
+                    return result
+                },
+                cancelEditData: function() {
+                    var result = this.callBase.apply(this, arguments);
+                    this._refreshSummary();
+                    return result
+                }
+            }
+        },
+        views: {
+            rowsView: {
+                _createRow: function(row) {
+                    var $row = this.callBase.apply(this, arguments);
+                    row && $row.addClass(row.rowType === DATAGRID_GROUP_FOOTER_ROW_TYPE ? DATAGRID_GROUP_FOOTER_CLASS : "");
+                    return $row
+                },
+                _renderCells: function($row, options) {
+                    this.callBase.apply(this, arguments);
+                    if ("group" === options.row.rowType && options.row.summaryCells && options.row.summaryCells.length) {
+                        this._renderGroupSummaryCells($row, options)
+                    }
+                },
+                _hasAlignByColumnSummaryItems: function(columnIndex, options) {
+                    return !type_1.isDefined(options.columns[columnIndex].groupIndex) && options.row.summaryCells[columnIndex].length
+                },
+                _getAlignByColumnCellCount: function(groupCellColSpan, options) {
+                    var alignByColumnCellCount = 0;
+                    for (var i = 1; i < groupCellColSpan; i++) {
+                        var columnIndex = options.row.summaryCells.length - i;
+                        alignByColumnCellCount = this._hasAlignByColumnSummaryItems(columnIndex, options) ? i : alignByColumnCellCount
+                    }
+                    return alignByColumnCellCount
+                },
+                _renderGroupSummaryCells: function($row, options) {
+                    var $groupCell = $row.children().last();
+                    var groupCellColSpan = Number($groupCell.attr("colSpan")) || 1;
+                    var alignByColumnCellCount = this._getAlignByColumnCellCount(groupCellColSpan, options);
+                    this._renderGroupSummaryCellsCore($groupCell, options, groupCellColSpan, alignByColumnCellCount)
+                },
+                _renderGroupSummaryCellsCore: function($groupCell, options, groupCellColSpan, alignByColumnCellCount) {
+                    if (alignByColumnCellCount > 0) {
+                        $groupCell.attr("colSpan", groupCellColSpan - alignByColumnCellCount);
+                        for (var i = 0; i < alignByColumnCellCount; i++) {
+                            var columnIndex = options.columns.length - alignByColumnCellCount + i;
+                            this._renderCell($groupCell.parent(), extend_1.extend({
+                                column: options.columns[columnIndex],
+                                columnIndex: this._getSummaryCellIndex(columnIndex, options.columns)
+                            }, options))
+                        }
+                    }
+                },
+                _getSummaryCellIndex: function(columnIndex) {
+                    return columnIndex
+                },
+                _getCellTemplate: function(options) {
+                    if (!options.column.command && !type_1.isDefined(options.column.groupIndex) && options.summaryItems && options.summaryItems.length) {
+                        return exports.renderSummaryCell
+                    }
+                    return this.callBase(options)
+                },
+                _getCellOptions: function(options) {
+                    var parameters = this.callBase(options);
+                    if (options.row.summaryCells) {
+                        return extend_1.extend(parameters, getSummaryCellOptions(this, options))
+                    }
+                    return parameters
+                }
+            }
+        }
+    }
+});