@lemon-fe/kits 1.0.0-21 → 1.0.0-210

package/es/components/DataGrid/modules/client-side-row-model/clientSideRowModel/clientSideRowModel.js

@@ -1,1160 +0,0 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
-
-var __decorate = this && this.__decorate || function (decorators, target, key, desc) {
-  var c = arguments.length,
-      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
-      d;
-  if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {
-    if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  }
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-
-import { _, Autowired, Bean, BeanStub, ChangedPath, Constants, Events, GridOptionsWrapper, Optional, PostConstruct, ClientSideRowModelSteps, RowNode, RowHighlightPosition } from "@ag-grid-community/core";
-import { ClientSideNodeManager } from "./clientSideNodeManager";
-var RecursionType;
-
-(function (RecursionType) {
-  RecursionType[RecursionType["Normal"] = 0] = "Normal";
-  RecursionType[RecursionType["AfterFilter"] = 1] = "AfterFilter";
-  RecursionType[RecursionType["AfterFilterAndSort"] = 2] = "AfterFilterAndSort";
-  RecursionType[RecursionType["PivotNodes"] = 3] = "PivotNodes";
-})(RecursionType || (RecursionType = {}));
-
-var ClientSideRowModel = /*#__PURE__*/function (_BeanStub) {
-  _inherits(ClientSideRowModel, _BeanStub);
-
-  var _super = _createSuper(ClientSideRowModel);
-
-  function ClientSideRowModel() {
-    var _this;
-
-    _classCallCheck(this, ClientSideRowModel);
-
-    _this = _super.apply(this, arguments);
-    _this.onRowHeightChanged_debounced = _.debounce(_this.onRowHeightChanged.bind(_assertThisInitialized(_this)), 100);
-    _this.rowsToDisplay = []; // the rows mapped to rows to display
-
-    return _this;
-  }
-
-  _createClass(ClientSideRowModel, [{
-    key: "init",
-    value: function init() {
-      var refreshEverythingFunc = this.refreshModel.bind(this, {
-        step: ClientSideRowModelSteps.EVERYTHING
-      });
-      var animate = !this.gridOptionsWrapper.isSuppressAnimationFrame();
-      var refreshEverythingAfterColsChangedFunc = this.refreshModel.bind(this, {
-        step: ClientSideRowModelSteps.EVERYTHING,
-        afterColumnsChanged: true,
-        keepRenderedRows: true,
-        animate: animate
-      });
-      this.addManagedListener(this.eventService, Events.EVENT_NEW_COLUMNS_LOADED, refreshEverythingAfterColsChangedFunc);
-      this.addManagedListener(this.eventService, Events.EVENT_COLUMN_ROW_GROUP_CHANGED, refreshEverythingFunc);
-      this.addManagedListener(this.eventService, Events.EVENT_COLUMN_VALUE_CHANGED, this.onValueChanged.bind(this));
-      this.addManagedListener(this.eventService, Events.EVENT_COLUMN_PIVOT_CHANGED, this.refreshModel.bind(this, {
-        step: ClientSideRowModelSteps.PIVOT
-      })); // this.addManagedListener(this.eventService, Events.EVENT_FILTER_CHANGED, this.onFilterChanged.bind(this));
-      // this.addManagedListener(this.eventService, Events.EVENT_SORT_CHANGED, this.onSortChanged.bind(this));
-
-      this.addManagedListener(this.eventService, Events.EVENT_COLUMN_PIVOT_MODE_CHANGED, refreshEverythingFunc);
-      var refreshMapListener = this.refreshModel.bind(this, {
-        step: ClientSideRowModelSteps.MAP,
-        keepRenderedRows: true,
-        animate: animate
-      });
-      this.addManagedListener(this.gridOptionsWrapper, GridOptionsWrapper.PROP_GROUP_REMOVE_SINGLE_CHILDREN, refreshMapListener);
-      this.addManagedListener(this.gridOptionsWrapper, GridOptionsWrapper.PROP_GROUP_REMOVE_LOWEST_SINGLE_CHILDREN, refreshMapListener);
-      this.rootNode = new RowNode(this.beans);
-      this.nodeManager = new ClientSideNodeManager(this.rootNode, this.gridOptionsWrapper, this.eventService, this.columnModel, this.selectionService, this.beans);
-    }
-  }, {
-    key: "start",
-    value: function start() {
-      var rowData = this.gridOptionsWrapper.getRowData();
-
-      if (rowData) {
-        this.setRowData(rowData);
-      }
-    }
-  }, {
-    key: "ensureRowHeightsValid",
-    value: function ensureRowHeightsValid(startPixel, endPixel, startLimitIndex, endLimitIndex) {
-      var atLeastOneChange;
-      var res = false; // we do this multiple times as changing the row heights can also change the first and last rows,
-      // so the first pass can make lots of rows smaller, which means the second pass we end up changing
-      // more rows.
-
-      do {
-        atLeastOneChange = false;
-        var rowAtStartPixel = this.getRowIndexAtPixel(startPixel);
-        var rowAtEndPixel = this.getRowIndexAtPixel(endPixel); // keep check to current page if doing pagination
-
-        var firstRow = Math.max(rowAtStartPixel, startLimitIndex);
-        var lastRow = Math.min(rowAtEndPixel, endLimitIndex);
-
-        for (var rowIndex = firstRow; rowIndex <= lastRow; rowIndex++) {
-          var rowNode = this.getRow(rowIndex);
-
-          if (rowNode.rowHeightEstimated) {
-            var rowHeight = this.gridOptionsWrapper.getRowHeightForNode(rowNode);
-            rowNode.setRowHeight(rowHeight.height);
-            atLeastOneChange = true;
-            res = true;
-          }
-        }
-
-        if (atLeastOneChange) {
-          this.setRowTopAndRowIndex();
-        }
-      } while (atLeastOneChange);
-
-      return res;
-    }
-  }, {
-    key: "setRowTopAndRowIndex",
-    value: function setRowTopAndRowIndex() {
-      var defaultRowHeight = this.gridOptionsWrapper.getDefaultRowHeight();
-      var nextRowTop = 0; // mapping displayed rows is not needed for this method, however it's used in
-      // clearRowTopAndRowIndex(), and given we are looping through this.rowsToDisplay here,
-      // we create the map here for performance reasons, so we don't loop a second time
-      // in clearRowTopAndRowIndex()
-
-      var displayedRowsMapped = new Set(); // we don't estimate if doing fullHeight or autoHeight, as all rows get rendered all the time
-      // with these two layouts.
-
-      var allowEstimate = this.gridOptionsWrapper.getDomLayout() === Constants.DOM_LAYOUT_NORMAL;
-
-      for (var i = 0; i < this.rowsToDisplay.length; i++) {
-        var rowNode = this.rowsToDisplay[i];
-
-        if (rowNode.id != null) {
-          displayedRowsMapped.add(rowNode.id);
-        }
-
-        if (rowNode.rowHeight == null) {
-          var rowHeight = this.gridOptionsWrapper.getRowHeightForNode(rowNode, allowEstimate, defaultRowHeight);
-          rowNode.setRowHeight(rowHeight.height, rowHeight.estimated);
-        }
-
-        rowNode.setRowTop(nextRowTop);
-        rowNode.setRowIndex(i);
-        nextRowTop += rowNode.rowHeight;
-      }
-
-      return displayedRowsMapped;
-    }
-  }, {
-    key: "clearRowTopAndRowIndex",
-    value: function clearRowTopAndRowIndex(changedPath, displayedRowsMapped) {
-      var changedPathActive = changedPath.isActive();
-
-      var clearIfNotDisplayed = function clearIfNotDisplayed(rowNode) {
-        if (rowNode && rowNode.id != null && !displayedRowsMapped.has(rowNode.id)) {
-          rowNode.clearRowTopAndRowIndex();
-        }
-      };
-
-      var recurse = function recurse(rowNode) {
-        clearIfNotDisplayed(rowNode);
-        clearIfNotDisplayed(rowNode.detailNode);
-        clearIfNotDisplayed(rowNode.sibling);
-
-        if (rowNode.hasChildren()) {
-          if (rowNode.childrenAfterGroup) {
-            // if a changedPath is active, it means we are here because of a transaction update or
-            // a change detection. neither of these impacts the open/closed state of groups. so if
-            // a group is not open this time, it was not open last time. so we know all closed groups
-            // already have their top positions cleared. so there is no need to traverse all the way
-            // when changedPath is active and the rowNode is not expanded.
-            var isRootNode = rowNode.level == -1; // we need to give special consideration for root node,
-            // as expanded=undefined for root node
-
-            var skipChildren = changedPathActive && !isRootNode && !rowNode.expanded;
-
-            if (!skipChildren) {
-              rowNode.childrenAfterGroup.forEach(recurse);
-            }
-          }
-        }
-      };
-
-      recurse(this.rootNode);
-    } // returns false if row was moved, otherwise true
-
-  }, {
-    key: "ensureRowsAtPixel",
-    value: function ensureRowsAtPixel(rowNodes, pixel) {
-      var _this2 = this;
-
-      var increment = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-      var indexAtPixelNow = this.getRowIndexAtPixel(pixel);
-      var rowNodeAtPixelNow = this.getRow(indexAtPixelNow);
-      var animate = !this.gridOptionsWrapper.isSuppressAnimationFrame();
-
-      if (rowNodeAtPixelNow === rowNodes[0]) {
-        return false;
-      }
-
-      rowNodes.forEach(function (rowNode) {
-        _.removeFromArray(_this2.rootNode.allLeafChildren, rowNode);
-      });
-      rowNodes.forEach(function (rowNode, idx) {
-        _.insertIntoArray(_this2.rootNode.allLeafChildren, rowNode, Math.max(indexAtPixelNow + increment, 0) + idx);
-      });
-      this.refreshModel({
-        step: ClientSideRowModelSteps.EVERYTHING,
-        keepRenderedRows: true,
-        keepEditingRows: true,
-        animate: animate
-      });
-      return true;
-    }
-  }, {
-    key: "highlightRowAtPixel",
-    value: function highlightRowAtPixel(rowNode, pixel) {
-      var indexAtPixelNow = pixel != null ? this.getRowIndexAtPixel(pixel) : null;
-      var rowNodeAtPixelNow = indexAtPixelNow != null ? this.getRow(indexAtPixelNow) : null;
-
-      if (!rowNodeAtPixelNow || !rowNode || rowNodeAtPixelNow === rowNode || pixel == null) {
-        if (this.lastHighlightedRow) {
-          this.lastHighlightedRow.setHighlighted(null);
-          this.lastHighlightedRow = null;
-        }
-
-        return;
-      }
-
-      var highlight = this.getHighlightPosition(pixel, rowNodeAtPixelNow);
-
-      if (this.lastHighlightedRow && this.lastHighlightedRow !== rowNodeAtPixelNow) {
-        this.lastHighlightedRow.setHighlighted(null);
-        this.lastHighlightedRow = null;
-      }
-
-      rowNodeAtPixelNow.setHighlighted(highlight);
-      this.lastHighlightedRow = rowNodeAtPixelNow;
-    }
-  }, {
-    key: "getHighlightPosition",
-    value: function getHighlightPosition(pixel, rowNode) {
-      if (!rowNode) {
-        var index = this.getRowIndexAtPixel(pixel);
-        rowNode = this.getRow(index || 0);
-
-        if (!rowNode) {
-          return RowHighlightPosition.Below;
-        }
-      }
-
-      var _rowNode = rowNode,
-          rowTop = _rowNode.rowTop,
-          rowHeight = _rowNode.rowHeight;
-      return pixel - rowTop < rowHeight / 2 ? RowHighlightPosition.Above : RowHighlightPosition.Below;
-    }
-  }, {
-    key: "getLastHighlightedRowNode",
-    value: function getLastHighlightedRowNode() {
-      return this.lastHighlightedRow;
-    }
-  }, {
-    key: "isLastRowIndexKnown",
-    value: function isLastRowIndexKnown() {
-      return true;
-    }
-  }, {
-    key: "getRowCount",
-    value: function getRowCount() {
-      if (this.rowsToDisplay) {
-        return this.rowsToDisplay.length;
-      }
-
-      return 0;
-    }
-  }, {
-    key: "getTopLevelRowCount",
-    value: function getTopLevelRowCount() {
-      var showingRootNode = this.rowsToDisplay && this.rowsToDisplay[0] === this.rootNode;
-
-      if (showingRootNode) {
-        return 1;
-      }
-
-      var filteredChildren = this.rootNode.childrenAfterAggFilter;
-      return filteredChildren ? filteredChildren.length : 0;
-    }
-  }, {
-    key: "getTopLevelRowDisplayedIndex",
-    value: function getTopLevelRowDisplayedIndex(topLevelIndex) {
-      var showingRootNode = this.rowsToDisplay && this.rowsToDisplay[0] === this.rootNode;
-
-      if (showingRootNode) {
-        return topLevelIndex;
-      }
-
-      var rowNode = this.rootNode.childrenAfterSort[topLevelIndex];
-
-      if (this.gridOptionsWrapper.isGroupHideOpenParents()) {
-        // if hideOpenParents, and this row open, then this row is now displayed at this index, first child is
-        while (rowNode.expanded && rowNode.childrenAfterSort && rowNode.childrenAfterSort.length > 0) {
-          rowNode = rowNode.childrenAfterSort[0];
-        }
-      }
-
-      return rowNode.rowIndex;
-    }
-  }, {
-    key: "getRowBounds",
-    value: function getRowBounds(index) {
-      if (_.missing(this.rowsToDisplay)) {
-        return null;
-      }
-
-      var rowNode = this.rowsToDisplay[index];
-
-      if (rowNode) {
-        return {
-          rowTop: rowNode.rowTop,
-          rowHeight: rowNode.rowHeight
-        };
-      }
-
-      return null;
-    }
-  }, {
-    key: "onRowGroupOpened",
-    value: function onRowGroupOpened() {
-      var animate = this.gridOptionsWrapper.isAnimateRows();
-      this.refreshModel({
-        step: ClientSideRowModelSteps.MAP,
-        keepRenderedRows: true,
-        animate: animate
-      });
-    }
-  }, {
-    key: "onFilterChanged",
-    value: function onFilterChanged(event) {
-      if (event.afterDataChange) {
-        return;
-      }
-
-      var animate = this.gridOptionsWrapper.isAnimateRows();
-      var primaryOrQuickFilterChanged = event.columns.length === 0 || event.columns.some(function (col) {
-        return col.isPrimary();
-      });
-      var step = primaryOrQuickFilterChanged ? ClientSideRowModelSteps.FILTER : ClientSideRowModelSteps.FILTER_AGGREGATES;
-      this.refreshModel({
-        step: step,
-        keepRenderedRows: true,
-        animate: animate
-      });
-    }
-  }, {
-    key: "onSortChanged",
-    value: function onSortChanged() {
-      var animate = this.gridOptionsWrapper.isAnimateRows();
-      this.refreshModel({
-        step: ClientSideRowModelSteps.SORT,
-        keepRenderedRows: true,
-        animate: animate,
-        keepEditingRows: true
-      });
-    }
-  }, {
-    key: "getType",
-    value: function getType() {
-      return Constants.ROW_MODEL_TYPE_CLIENT_SIDE;
-    }
-  }, {
-    key: "onValueChanged",
-    value: function onValueChanged() {
-      if (this.columnModel.isPivotActive()) {
-        this.refreshModel({
-          step: ClientSideRowModelSteps.PIVOT
-        });
-      } else {
-        this.refreshModel({
-          step: ClientSideRowModelSteps.AGGREGATE
-        });
-      }
-    }
-  }, {
-    key: "createChangePath",
-    value: function createChangePath(rowNodeTransactions) {
-      // for updates, if the row is updated at all, then we re-calc all the values
-      // in that row. we could compare each value to each old value, however if we
-      // did this, we would be calling the valueService twice, once on the old value
-      // and once on the new value. so it's less valueGetter calls if we just assume
-      // each column is different. that way the changedPath is used so that only
-      // the impacted parent rows are recalculated, parents who's children have
-      // not changed are not impacted.
-      var noTransactions = _.missingOrEmpty(rowNodeTransactions);
-
-      var changedPath = new ChangedPath(false, this.rootNode);
-
-      if (noTransactions || this.gridOptionsWrapper.isTreeData()) {
-        changedPath.setInactive();
-      }
-
-      return changedPath;
-    }
-  }, {
-    key: "isSuppressModelUpdateAfterUpdateTransaction",
-    value: function isSuppressModelUpdateAfterUpdateTransaction(params) {
-      if (!this.gridOptionsWrapper.isSuppressModelUpdateAfterUpdateTransaction()) {
-        return false;
-      } // return true if we are only doing update transactions
-
-
-      if (params.rowNodeTransactions == null) {
-        return false;
-      }
-
-      var transWithAddsOrDeletes = params.rowNodeTransactions.filter(function (tx) {
-        return tx.add != null && tx.add.length > 0 || tx.remove != null && tx.remove.length > 0;
-      });
-      var transactionsContainUpdatesOnly = transWithAddsOrDeletes == null || transWithAddsOrDeletes.length == 0;
-      return transactionsContainUpdatesOnly;
-    }
-  }, {
-    key: "refreshModel",
-    value: function refreshModel(params) {
-      if (this.isSuppressModelUpdateAfterUpdateTransaction(params)) {
-        return;
-      } // this goes through the pipeline of stages. what's in my head is similar
-      // to the diagram on this page:
-      // http://commons.apache.org/sandbox/commons-pipeline/pipeline_basics.html
-      // however we want to keep the results of each stage, hence we manually call
-      // each step rather than have them chain each other.
-      // fallthrough in below switch is on purpose,
-      // eg if STEP_FILTER, then all steps below this
-      // step get done
-      // let start: number;
-      // console.log('======= start =======');
-
-
-      var changedPath = this.createChangePath(params.rowNodeTransactions);
-
-      switch (params.step) {
-        case ClientSideRowModelSteps.EVERYTHING:
-          this.doRowGrouping(params.groupState, params.rowNodeTransactions, params.rowNodeOrder, changedPath, !!params.afterColumnsChanged);
-
-        case ClientSideRowModelSteps.FILTER:
-          this.doFilter(changedPath);
-
-        case ClientSideRowModelSteps.PIVOT:
-          this.doPivot(changedPath);
-
-        case ClientSideRowModelSteps.AGGREGATE:
-          // depends on agg fields
-          this.doAggregate(changedPath);
-
-        case ClientSideRowModelSteps.FILTER_AGGREGATES:
-          this.doFilterAggregates(changedPath);
-
-        case ClientSideRowModelSteps.SORT:
-          this.doSort(params.rowNodeTransactions, changedPath);
-
-        case ClientSideRowModelSteps.MAP:
-          this.doRowsToDisplay();
-      } // set all row tops to null, then set row tops on all visible rows. if we don't
-      // do this, then the algorithm below only sets row tops, old row tops from old rows
-      // will still lie around
-
-
-      var displayedNodesMapped = this.setRowTopAndRowIndex();
-      this.clearRowTopAndRowIndex(changedPath, displayedNodesMapped);
-      var event = {
-        type: Events.EVENT_MODEL_UPDATED,
-        animate: params.animate,
-        keepRenderedRows: params.keepRenderedRows,
-        newData: params.newData,
-        newPage: false,
-        keepUndoRedoStack: params.keepUndoRedoStack
-      };
-      this.eventService.dispatchEvent(event);
-    }
-  }, {
-    key: "isEmpty",
-    value: function isEmpty() {
-      var rowsMissing = _.missing(this.rootNode.allLeafChildren) || this.rootNode.allLeafChildren.length === 0;
-      return _.missing(this.rootNode) || rowsMissing || !this.columnModel.isReady();
-    }
-  }, {
-    key: "isRowsToRender",
-    value: function isRowsToRender() {
-      return _.exists(this.rowsToDisplay) && this.rowsToDisplay.length > 0;
-    }
-  }, {
-    key: "getNodesInRangeForSelection",
-    value: function getNodesInRangeForSelection(firstInRange, lastInRange) {
-      // if lastSelectedNode is missing, we start at the first row
-      var firstRowHit = !lastInRange;
-      var lastRowHit = false;
-      var lastRow;
-      var result = [];
-      var groupsSelectChildren = this.gridOptionsWrapper.isGroupSelectsChildren();
-      this.forEachNodeAfterFilterAndSort(function (rowNode) {
-        var lookingForLastRow = firstRowHit && !lastRowHit; // check if we need to flip the select switch
-
-        if (!firstRowHit) {
-          if (rowNode === lastInRange || rowNode === firstInRange) {
-            firstRowHit = true;
-          }
-        }
-
-        var skipThisGroupNode = rowNode.group && groupsSelectChildren;
-
-        if (!skipThisGroupNode) {
-          var inRange = firstRowHit && !lastRowHit;
-          var childOfLastRow = rowNode.isParentOfNode(lastRow);
-
-          if (inRange || childOfLastRow) {
-            result.push(rowNode);
-          }
-        }
-
-        if (lookingForLastRow) {
-          if (rowNode === lastInRange || rowNode === firstInRange) {
-            lastRowHit = true;
-
-            if (rowNode === lastInRange) {
-              lastRow = lastInRange;
-            } else {
-              lastRow = firstInRange;
-            }
-          }
-        }
-      });
-      return result;
-    }
-  }, {
-    key: "setDatasource",
-    value: function setDatasource(datasource) {
-      console.error('AG Grid: should never call setDatasource on clientSideRowController');
-    }
-  }, {
-    key: "getTopLevelNodes",
-    value: function getTopLevelNodes() {
-      return this.rootNode ? this.rootNode.childrenAfterGroup : null;
-    }
-  }, {
-    key: "getRootNode",
-    value: function getRootNode() {
-      return this.rootNode;
-    }
-  }, {
-    key: "getRow",
-    value: function getRow(index) {
-      return this.rowsToDisplay[index];
-    }
-  }, {
-    key: "isRowPresent",
-    value: function isRowPresent(rowNode) {
-      return this.rowsToDisplay.indexOf(rowNode) >= 0;
-    }
-  }, {
-    key: "getRowIndexAtPixel",
-    value: function getRowIndexAtPixel(pixelToMatch) {
-      if (this.isEmpty() || this.rowsToDisplay.length === 0) {
-        return -1;
-      } // do binary search of tree
-      // http://oli.me.uk/2013/06/08/searching-javascript-arrays-with-a-binary-search/
-
-
-      var bottomPointer = 0;
-      var topPointer = this.rowsToDisplay.length - 1; // quick check, if the pixel is out of bounds, then return last row
-
-      if (pixelToMatch <= 0) {
-        // if pixel is less than or equal zero, it's always the first row
-        return 0;
-      }
-
-      var lastNode = _.last(this.rowsToDisplay);
-
-      if (lastNode.rowTop <= pixelToMatch) {
-        return this.rowsToDisplay.length - 1;
-      }
-
-      var oldBottomPointer = -1;
-      var oldTopPointer = -1;
-
-      while (true) {
-        var midPointer = Math.floor((bottomPointer + topPointer) / 2);
-        var currentRowNode = this.rowsToDisplay[midPointer];
-
-        if (this.isRowInPixel(currentRowNode, pixelToMatch)) {
-          return midPointer;
-        }
-
-        if (currentRowNode.rowTop < pixelToMatch) {
-          bottomPointer = midPointer + 1;
-        } else if (currentRowNode.rowTop > pixelToMatch) {
-          topPointer = midPointer - 1;
-        } // infinite loops happen when there is space between rows. this can happen
-        // when Auto Height is active, cos we re-calculate row tops asyncronously
-        // when row heights change, which can temporarly result in gaps between rows.
-
-
-        var caughtInInfiniteLoop = oldBottomPointer === bottomPointer && oldTopPointer === topPointer;
-
-        if (caughtInInfiniteLoop) {
-          return midPointer;
-        }
-
-        oldBottomPointer = bottomPointer;
-        oldTopPointer = topPointer;
-      }
-    }
-  }, {
-    key: "isRowInPixel",
-    value: function isRowInPixel(rowNode, pixelToMatch) {
-      var topPixel = rowNode.rowTop;
-      var bottomPixel = rowNode.rowTop + rowNode.rowHeight;
-      var pixelInRow = topPixel <= pixelToMatch && bottomPixel > pixelToMatch;
-      return pixelInRow;
-    }
-  }, {
-    key: "forEachLeafNode",
-    value: function forEachLeafNode(callback) {
-      if (this.rootNode.allLeafChildren) {
-        this.rootNode.allLeafChildren.forEach(function (rowNode, index) {
-          return callback(rowNode, index);
-        });
-      }
-    }
-  }, {
-    key: "forEachNode",
-    value: function forEachNode(callback) {
-      this.recursivelyWalkNodesAndCallback(this.rootNode.childrenAfterGroup, callback, RecursionType.Normal, 0);
-    }
-  }, {
-    key: "forEachNodeAfterFilter",
-    value: function forEachNodeAfterFilter(callback) {
-      this.recursivelyWalkNodesAndCallback(this.rootNode.childrenAfterAggFilter, callback, RecursionType.AfterFilter, 0);
-    }
-  }, {
-    key: "forEachNodeAfterFilterAndSort",
-    value: function forEachNodeAfterFilterAndSort(callback) {
-      this.recursivelyWalkNodesAndCallback(this.rootNode.childrenAfterSort, callback, RecursionType.AfterFilterAndSort, 0);
-    }
-  }, {
-    key: "forEachPivotNode",
-    value: function forEachPivotNode(callback) {
-      this.recursivelyWalkNodesAndCallback([this.rootNode], callback, RecursionType.PivotNodes, 0);
-    } // iterates through each item in memory, and calls the callback function
-    // nodes - the rowNodes to traverse
-    // callback - the user provided callback
-    // recursion type - need this to know what child nodes to recurse, eg if looking at all nodes, or filtered notes etc
-    // index - works similar to the index in forEach in javascript's array function
-
-  }, {
-    key: "recursivelyWalkNodesAndCallback",
-    value: function recursivelyWalkNodesAndCallback(nodes, callback, recursionType, index) {
-      if (!nodes) {
-        return index;
-      }
-
-      for (var i = 0; i < nodes.length; i++) {
-        var node = nodes[i];
-        callback(node, index++); // go to the next level if it is a group
-
-        if (node.hasChildren()) {
-          // depending on the recursion type, we pick a difference set of children
-          var nodeChildren = null;
-
-          switch (recursionType) {
-            case RecursionType.Normal:
-              nodeChildren = node.childrenAfterGroup;
-              break;
-
-            case RecursionType.AfterFilter:
-              nodeChildren = node.childrenAfterAggFilter;
-              break;
-
-            case RecursionType.AfterFilterAndSort:
-              nodeChildren = node.childrenAfterSort;
-              break;
-
-            case RecursionType.PivotNodes:
-              // for pivot, we don't go below leafGroup levels
-              nodeChildren = !node.leafGroup ? node.childrenAfterSort : null;
-              break;
-          }
-
-          if (nodeChildren) {
-            index = this.recursivelyWalkNodesAndCallback(nodeChildren, callback, recursionType, index);
-          }
-        }
-      }
-
-      return index;
-    } // it's possible to recompute the aggregate without doing the other parts
-    // + gridApi.recomputeAggregates()
-
-  }, {
-    key: "doAggregate",
-    value: function doAggregate(changedPath) {
-      if (this.aggregationStage) {
-        this.aggregationStage.execute({
-          rowNode: this.rootNode,
-          changedPath: changedPath
-        });
-      }
-    }
-  }, {
-    key: "doFilterAggregates",
-    value: function doFilterAggregates(changedPath) {
-      if (this.filterAggregatesStage) {
-        this.filterAggregatesStage.execute({
-          rowNode: this.rootNode,
-          changedPath: changedPath
-        });
-      } else {
-        // If filterAggregatesStage is undefined, then so is the grouping stage, so all children should be on the rootNode.
-        this.rootNode.childrenAfterAggFilter = this.rootNode.childrenAfterFilter;
-      }
-    } // + gridApi.expandAll()
-    // + gridApi.collapseAll()
-
-  }, {
-    key: "expandOrCollapseAll",
-    value: function expandOrCollapseAll(expand) {
-      var usingTreeData = this.gridOptionsWrapper.isTreeData();
-      var usingPivotMode = this.columnModel.isPivotActive();
-
-      var recursiveExpandOrCollapse = function recursiveExpandOrCollapse(rowNodes) {
-        if (!rowNodes) {
-          return;
-        }
-
-        rowNodes.forEach(function (rowNode) {
-          var actionRow = function actionRow() {
-            rowNode.expanded = expand;
-            recursiveExpandOrCollapse(rowNode.childrenAfterGroup);
-          };
-
-          if (usingTreeData) {
-            var hasChildren = _.exists(rowNode.childrenAfterGroup);
-
-            if (hasChildren) {
-              actionRow();
-            }
-
-            return;
-          }
-
-          if (usingPivotMode) {
-            var notLeafGroup = !rowNode.leafGroup;
-
-            if (notLeafGroup) {
-              actionRow();
-            }
-
-            return;
-          }
-
-          var isRowGroup = rowNode.group;
-
-          if (isRowGroup) {
-            actionRow();
-          }
-        });
-      };
-
-      if (this.rootNode) {
-        recursiveExpandOrCollapse(this.rootNode.childrenAfterGroup);
-      }
-
-      this.refreshModel({
-        step: ClientSideRowModelSteps.MAP
-      });
-      var eventSource = expand ? 'expandAll' : 'collapseAll';
-      var event = {
-        type: Events.EVENT_EXPAND_COLLAPSE_ALL,
-        source: eventSource
-      };
-      this.eventService.dispatchEvent(event);
-    }
-  }, {
-    key: "doSort",
-    value: function doSort(rowNodeTransactions, changedPath) {
-      this.sortStage.execute({
-        rowNode: this.rootNode,
-        rowNodeTransactions: rowNodeTransactions,
-        changedPath: changedPath
-      });
-    }
-  }, {
-    key: "doRowGrouping",
-    value: function doRowGrouping(groupState, rowNodeTransactions, rowNodeOrder, changedPath, afterColumnsChanged) {
-      if (this.groupStage) {
-        if (rowNodeTransactions) {
-          this.groupStage.execute({
-            rowNode: this.rootNode,
-            rowNodeTransactions: rowNodeTransactions,
-            rowNodeOrder: rowNodeOrder,
-            changedPath: changedPath
-          });
-        } else {
-          this.groupStage.execute({
-            rowNode: this.rootNode,
-            changedPath: changedPath,
-            afterColumnsChanged: afterColumnsChanged
-          }); // set open/closed state on groups
-
-          this.restoreGroupState(groupState);
-        }
-
-        if (this.gridOptionsWrapper.isGroupSelectsChildren()) {
-          this.selectionService.updateGroupsFromChildrenSelections(changedPath);
-        }
-      } else {
-        this.rootNode.childrenAfterGroup = this.rootNode.allLeafChildren;
-
-        if (this.rootNode.sibling) {
-          this.rootNode.sibling.childrenAfterGroup = this.rootNode.childrenAfterGroup;
-        }
-
-        this.rootNode.updateHasChildren();
-      }
-    }
-  }, {
-    key: "restoreGroupState",
-    value: function restoreGroupState(groupState) {
-      if (!groupState) {
-        return;
-      }
-
-      _.traverseNodesWithKey(this.rootNode.childrenAfterGroup, function (node, key) {
-        // if the group was open last time, then open it this time. however
-        // if was not open last time, then don't touch the group, so the 'groupDefaultExpanded'
-        // setting will take effect.
-        if (typeof groupState[key] === 'boolean') {
-          node.expanded = groupState[key];
-        }
-      });
-    }
-  }, {
-    key: "doFilter",
-    value: function doFilter(changedPath) {
-      this.filterStage.execute({
-        rowNode: this.rootNode,
-        changedPath: changedPath
-      });
-    }
-  }, {
-    key: "doPivot",
-    value: function doPivot(changedPath) {
-      if (this.pivotStage) {
-        this.pivotStage.execute({
-          rowNode: this.rootNode,
-          changedPath: changedPath
-        });
-      }
-    }
-  }, {
-    key: "getGroupState",
-    value: function getGroupState() {
-      if (!this.rootNode.childrenAfterGroup || !this.gridOptionsWrapper.isRememberGroupStateWhenNewData()) {
-        return null;
-      }
-
-      var result = {};
-
-      _.traverseNodesWithKey(this.rootNode.childrenAfterGroup, function (node, key) {
-        return result[key] = node.expanded;
-      });
-
-      return result;
-    }
-  }, {
-    key: "getCopyOfNodesMap",
-    value: function getCopyOfNodesMap() {
-      return this.nodeManager.getCopyOfNodesMap();
-    }
-  }, {
-    key: "getRowNode",
-    value: function getRowNode(id) {
-      // although id is typed a string, this could be called by the user, and they could have passed a number
-      var idIsGroup = typeof id == 'string' && id.indexOf(RowNode.ID_PREFIX_ROW_GROUP) == 0;
-
-      if (idIsGroup) {
-        // only one users complained about getRowNode not working for groups, after years of
-        // this working for normal rows. so have done quick implementation. if users complain
-        // about performance, then GroupStage should store / manage created groups in a map,
-        // which is a chunk of work.
-        var res = undefined;
-        this.forEachNode(function (node) {
-          if (node.id === id) {
-            res = node;
-          }
-        });
-        return res;
-      }
-
-      return this.nodeManager.getRowNode(id);
-    } // rows: the rows to put into the model
-
-  }, {
-    key: "setRowData",
-    value: function setRowData(rowData) {
-      // no need to invalidate cache, as the cache is stored on the rowNode,
-      // so new rowNodes means the cache is wiped anyway.
-      // remember group state, so we can expand groups that should be expanded
-      var groupState = this.getGroupState();
-      this.nodeManager.setRowData(rowData); // - clears selection
-
-      this.selectionService.reset(); // - updates filters
-
-      this.filterManager.onNewRowsLoaded('rowDataUpdated'); // this event kicks off:
-      // - shows 'no rows' overlay if needed
-
-      var rowDataUpdatedEvent = {
-        type: Events.EVENT_ROW_DATA_UPDATED
-      };
-      this.eventService.dispatchEvent(rowDataUpdatedEvent);
-      this.refreshModel({
-        step: ClientSideRowModelSteps.EVERYTHING,
-        groupState: groupState,
-        newData: true
-      });
-    }
-  }, {
-    key: "batchUpdateRowData",
-    value: function batchUpdateRowData(rowDataTransaction, callback) {
-      var _this3 = this;
-
-      if (this.applyAsyncTransactionsTimeout == null) {
-        this.rowDataTransactionBatch = [];
-        var waitMillis = this.gridOptionsWrapper.getAsyncTransactionWaitMillis();
-        this.applyAsyncTransactionsTimeout = window.setTimeout(function () {
-          _this3.executeBatchUpdateRowData();
-        }, waitMillis);
-      }
-
-      this.rowDataTransactionBatch.push({
-        rowDataTransaction: rowDataTransaction,
-        callback: callback
-      });
-    }
-  }, {
-    key: "flushAsyncTransactions",
-    value: function flushAsyncTransactions() {
-      if (this.applyAsyncTransactionsTimeout != null) {
-        clearTimeout(this.applyAsyncTransactionsTimeout);
-        this.executeBatchUpdateRowData();
-      }
-    }
-  }, {
-    key: "executeBatchUpdateRowData",
-    value: function executeBatchUpdateRowData() {
-      var _this4 = this;
-
-      this.valueCache.onDataChanged();
-      var callbackFuncsBound = [];
-      var rowNodeTrans = []; // The rowGroup stage uses rowNodeOrder if order was provided. if we didn't pass 'true' to
-      // commonUpdateRowData, using addIndex would have no effect when grouping.
-
-      var forceRowNodeOrder = false;
-
-      if (this.rowDataTransactionBatch) {
-        this.rowDataTransactionBatch.forEach(function (tranItem) {
-          var rowNodeTran = _this4.nodeManager.updateRowData(tranItem.rowDataTransaction, undefined);
-
-          rowNodeTrans.push(rowNodeTran);
-
-          if (tranItem.callback) {
-            callbackFuncsBound.push(tranItem.callback.bind(null, rowNodeTran));
-          }
-
-          if (typeof tranItem.rowDataTransaction.addIndex === 'number') {
-            forceRowNodeOrder = true;
-          }
-        });
-      }
-
-      this.commonUpdateRowData(rowNodeTrans, undefined, forceRowNodeOrder); // do callbacks in next VM turn so it's async
-
-      if (callbackFuncsBound.length > 0) {
-        window.setTimeout(function () {
-          callbackFuncsBound.forEach(function (func) {
-            return func();
-          });
-        }, 0);
-      }
-
-      if (rowNodeTrans.length > 0) {
-        var event = {
-          type: Events.EVENT_ASYNC_TRANSACTIONS_FLUSHED,
-          results: rowNodeTrans
-        };
-        this.eventService.dispatchEvent(event);
-      }
-
-      this.rowDataTransactionBatch = null;
-      this.applyAsyncTransactionsTimeout = undefined;
-    }
-  }, {
-    key: "updateRowData",
-    value: function updateRowData(rowDataTran, rowNodeOrder) {
-      this.valueCache.onDataChanged();
-      var rowNodeTran = this.nodeManager.updateRowData(rowDataTran, rowNodeOrder); // if doing immutableData, addIndex is never present. however if doing standard transaction, and user
-      // provided addIndex, then this is used in updateRowData. However if doing Enterprise, then the rowGroup
-      // stage also uses the
-
-      var forceRowNodeOrder = typeof rowDataTran.addIndex === 'number';
-      this.commonUpdateRowData([rowNodeTran], rowNodeOrder, forceRowNodeOrder);
-      return rowNodeTran;
-    }
-  }, {
-    key: "createRowNodeOrder",
-    value: function createRowNodeOrder() {
-      var suppressSortOrder = this.gridOptionsWrapper.isSuppressMaintainUnsortedOrder();
-
-      if (suppressSortOrder) {
-        return;
-      }
-
-      var orderMap = {};
-
-      if (this.rootNode && this.rootNode.allLeafChildren) {
-        for (var index = 0; index < this.rootNode.allLeafChildren.length; index++) {
-          var node = this.rootNode.allLeafChildren[index];
-          orderMap[node.id] = index;
-        }
-      }
-
-      return orderMap;
-    } // common to updateRowData and batchUpdateRowData
-
-  }, {
-    key: "commonUpdateRowData",
-    value: function commonUpdateRowData(rowNodeTrans, rowNodeOrder, forceRowNodeOrder) {
-      var animate = !this.gridOptionsWrapper.isSuppressAnimationFrame();
-
-      if (forceRowNodeOrder) {
-        rowNodeOrder = this.createRowNodeOrder();
-      }
-
-      this.refreshModel({
-        step: ClientSideRowModelSteps.EVERYTHING,
-        rowNodeTransactions: rowNodeTrans,
-        rowNodeOrder: rowNodeOrder,
-        keepRenderedRows: true,
-        keepEditingRows: true,
-        animate: animate
-      }); // - updates filters
-
-      this.filterManager.onNewRowsLoaded('rowDataUpdated');
-      var event = {
-        type: Events.EVENT_ROW_DATA_UPDATED
-      };
-      this.eventService.dispatchEvent(event);
-    }
-  }, {
-    key: "doRowsToDisplay",
-    value: function doRowsToDisplay() {
-      this.rowsToDisplay = this.flattenStage.execute({
-        rowNode: this.rootNode
-      });
-    }
-  }, {
-    key: "onRowHeightChanged",
-    value: function onRowHeightChanged() {
-      this.refreshModel({
-        step: ClientSideRowModelSteps.MAP,
-        keepRenderedRows: true,
-        keepEditingRows: true,
-        keepUndoRedoStack: true
-      });
-    }
-    /** This method is debounced. It is used for row auto-height. If we don't debounce,
-     * then the Row Models will end up recalculating each row position
-     * for each row height change and result in the Row Renderer laying out rows.
-     * This is particularly bad if using print layout, and showing eg 1,000 rows,
-     * each row will change it's height, causing Row Model to update 1,000 times.
-     */
-
-  }, {
-    key: "onRowHeightChangedDebounced",
-    value: function onRowHeightChangedDebounced() {
-      this.onRowHeightChanged_debounced();
-    }
-  }, {
-    key: "resetRowHeights",
-    value: function resetRowHeights() {
-      var atLeastOne = false;
-      this.forEachNode(function (rowNode) {
-        rowNode.setRowHeight(rowNode.rowHeight, true); // we keep the height each row is at, however we set estimated=true rather than clear the height.
-        // this means the grid will not reset the row heights back to defaults, rather it will re-calc
-        // the height for each row as the row is displayed. otherwise the scroll will jump when heights are reset.
-
-        var detailNode = rowNode.detailNode;
-
-        if (detailNode) {
-          detailNode.setRowHeight(detailNode.rowHeight, true);
-        }
-
-        atLeastOne = true;
-      });
-
-      if (atLeastOne) {
-        this.onRowHeightChanged();
-      }
-    }
-  }]);
-
-  return ClientSideRowModel;
-}(BeanStub);
-
-__decorate([Autowired('columnModel')], ClientSideRowModel.prototype, "columnModel", void 0);
-
-__decorate([Autowired('selectionService')], ClientSideRowModel.prototype, "selectionService", void 0);
-
-__decorate([Autowired('filterManager')], ClientSideRowModel.prototype, "filterManager", void 0);
-
-__decorate([Autowired('valueCache')], ClientSideRowModel.prototype, "valueCache", void 0);
-
-__decorate([Autowired('beans')], ClientSideRowModel.prototype, "beans", void 0);
-
-__decorate([Autowired('filterStage')], ClientSideRowModel.prototype, "filterStage", void 0);
-
-__decorate([Autowired('sortStage')], ClientSideRowModel.prototype, "sortStage", void 0);
-
-__decorate([Autowired('flattenStage')], ClientSideRowModel.prototype, "flattenStage", void 0);
-
-__decorate([Optional('groupStage')], ClientSideRowModel.prototype, "groupStage", void 0);
-
-__decorate([Optional('aggregationStage')], ClientSideRowModel.prototype, "aggregationStage", void 0);
-
-__decorate([Optional('pivotStage')], ClientSideRowModel.prototype, "pivotStage", void 0);
-
-__decorate([Optional('filterAggregatesStage')], ClientSideRowModel.prototype, "filterAggregatesStage", void 0);
-
-__decorate([PostConstruct], ClientSideRowModel.prototype, "init", null);
-
-ClientSideRowModel = __decorate([Bean('rowModel')], ClientSideRowModel);
-export { ClientSideRowModel };