@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/server-side-row-model/serverSideRowModel/stores/fullStore.js

@@ -0,0 +1,876 @@
+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, Events, NumberSequence, PostConstruct, PreDestroy, RowNodeBlock, ServerSideTransactionResultStatus } from '@ag-grid-community/core';
+export var FullStore = /*#__PURE__*/function (_RowNodeBlock) {
+  _inherits(FullStore, _RowNodeBlock);
+
+  var _super = _createSuper(FullStore);
+
+  function FullStore(ssrmParams, storeParams, parentRowNode) {
+    var _this;
+
+    _classCallCheck(this, FullStore);
+
+    // finite block represents a cache with just one block, thus 0 is the id, it's the first block
+    _this = _super.call(this, 0);
+    _this.nodeIdSequence = new NumberSequence();
+    _this.info = {};
+    _this.ssrmParams = ssrmParams;
+    _this.parentRowNode = parentRowNode;
+    _this.level = parentRowNode.level + 1;
+    _this.groupLevel = ssrmParams.rowGroupCols ? _this.level < ssrmParams.rowGroupCols.length : undefined;
+    _this.leafGroup = ssrmParams.rowGroupCols ? _this.level === ssrmParams.rowGroupCols.length - 1 : false;
+    return _this;
+  }
+
+  _createClass(FullStore, [{
+    key: "postConstruct",
+    value: function postConstruct() {
+      var _this2 = this;
+
+      this.usingTreeData = this.gridOptionsWrapper.isTreeData();
+      this.nodeIdPrefix = this.blockUtils.createNodeIdPrefix(this.parentRowNode);
+
+      if (!this.usingTreeData && this.groupLevel) {
+        var groupColVo = this.ssrmParams.rowGroupCols[this.level];
+        this.groupField = groupColVo.field;
+        this.rowGroupColumn = this.columnModel.getRowGroupColumns()[this.level];
+      }
+
+      var initialRowCount = 1;
+      var isRootStore = this.parentRowNode.level === -1;
+      var userInitialRowCount = this.gridOptionsWrapper.getServerSideInitialRowCount();
+
+      if (isRootStore && userInitialRowCount !== undefined) {
+        initialRowCount = userInitialRowCount;
+      }
+
+      this.initialiseRowNodes(initialRowCount);
+      this.rowNodeBlockLoader.addBlock(this);
+      this.addDestroyFunc(function () {
+        return _this2.rowNodeBlockLoader.removeBlock(_this2);
+      });
+    }
+  }, {
+    key: "destroyRowNodes",
+    value: function destroyRowNodes() {
+      this.blockUtils.destroyRowNodes(this.allRowNodes);
+      this.allRowNodes = [];
+      this.nodesAfterSort = [];
+      this.nodesAfterFilter = [];
+      this.allNodesMap = {};
+    }
+  }, {
+    key: "initialiseRowNodes",
+    value: function initialiseRowNodes(loadingRowsCount) {
+      var failedLoad = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      this.destroyRowNodes();
+
+      for (var i = 0; i < loadingRowsCount; i++) {
+        var loadingRowNode = this.blockUtils.createRowNode({
+          field: this.groupField,
+          group: this.groupLevel,
+          leafGroup: this.leafGroup,
+          level: this.level,
+          parent: this.parentRowNode,
+          rowGroupColumn: this.rowGroupColumn
+        });
+
+        if (failedLoad) {
+          loadingRowNode.failedLoad = true;
+        }
+
+        this.allRowNodes.push(loadingRowNode);
+        this.nodesAfterFilter.push(loadingRowNode);
+        this.nodesAfterSort.push(loadingRowNode);
+      }
+    }
+  }, {
+    key: "getBlockStateJson",
+    value: function getBlockStateJson() {
+      return {
+        id: this.nodeIdPrefix ? this.nodeIdPrefix : '',
+        state: this.getState()
+      };
+    }
+  }, {
+    key: "loadFromDatasource",
+    value: function loadFromDatasource() {
+      this.storeUtils.loadFromDatasource({
+        startRow: undefined,
+        endRow: undefined,
+        parentBlock: this,
+        parentNode: this.parentRowNode,
+        storeParams: this.ssrmParams,
+        successCallback: this.pageLoaded.bind(this, this.getVersion()),
+        success: this.success.bind(this, this.getVersion()),
+        failCallback: this.pageLoadFailed.bind(this, this.getVersion()),
+        fail: this.pageLoadFailed.bind(this, this.getVersion())
+      });
+    }
+  }, {
+    key: "getStartRow",
+    value: function getStartRow() {
+      return 0; // always zero as not in a cache
+    }
+  }, {
+    key: "getEndRow",
+    value: function getEndRow() {
+      return this.nodesAfterSort.length;
+    }
+  }, {
+    key: "createDataNode",
+    value: function createDataNode(data, index) {
+      var rowNode = this.blockUtils.createRowNode({
+        field: this.groupField,
+        group: this.groupLevel,
+        leafGroup: this.leafGroup,
+        level: this.level,
+        parent: this.parentRowNode,
+        rowGroupColumn: this.rowGroupColumn
+      });
+
+      if (index != null) {
+        _.insertIntoArray(this.allRowNodes, rowNode, index);
+      } else {
+        this.allRowNodes.push(rowNode);
+      }
+
+      var defaultId = this.prefixId(this.nodeIdSequence.next());
+      this.blockUtils.setDataIntoRowNode(rowNode, data, defaultId, undefined);
+      this.nodeManager.addRowNode(rowNode);
+      this.blockUtils.checkOpenByDefault(rowNode);
+      this.allNodesMap[rowNode.id] = rowNode;
+      return rowNode;
+    }
+  }, {
+    key: "prefixId",
+    value: function prefixId(id) {
+      if (this.nodeIdPrefix) {
+        return this.nodeIdPrefix + '-' + id;
+      } else {
+        return id.toString();
+      }
+    }
+  }, {
+    key: "processServerFail",
+    value: function processServerFail() {
+      this.initialiseRowNodes(1, true);
+      this.fireStoreUpdatedEvent();
+      this.flushAsyncTransactions();
+    }
+  }, {
+    key: "processServerResult",
+    value: function processServerResult(params) {
+      if (!this.isAlive()) {
+        return;
+      }
+
+      var info = params.storeInfo || params.groupLevelInfo;
+
+      if (info) {
+        Object.assign(this.info, info);
+      }
+
+      var nodesToRecycle = this.allRowNodes.length > 0 ? this.allNodesMap : undefined;
+      this.allRowNodes = [];
+      this.nodesAfterSort = [];
+      this.nodesAfterFilter = [];
+      this.allNodesMap = {};
+
+      if (!params.rowData) {
+        var message = 'AG Grid: "params.data" is missing from Server-Side Row Model success() callback. Please use the "data" attribute. If no data is returned, set an empty list.';
+
+        _.doOnce(function () {
+          return console.warn(message, params);
+        }, 'FullStore.noData');
+      }
+
+      this.createOrRecycleNodes(nodesToRecycle, params.rowData);
+
+      if (nodesToRecycle) {
+        this.blockUtils.destroyRowNodes(_.getAllValuesInObject(nodesToRecycle));
+      }
+
+      this.filterAndSortNodes();
+      this.fireStoreUpdatedEvent();
+      this.flushAsyncTransactions();
+    }
+  }, {
+    key: "createOrRecycleNodes",
+    value: function createOrRecycleNodes(nodesToRecycle, rowData) {
+      var _this3 = this;
+
+      if (!rowData) {
+        return;
+      }
+
+      var lookupNodeToRecycle = function lookupNodeToRecycle(data) {
+        if (!nodesToRecycle) {
+          return undefined;
+        }
+
+        var getRowIdFunc = _this3.gridOptionsWrapper.getRowIdFunc();
+
+        if (!getRowIdFunc) {
+          return undefined;
+        }
+
+        var parentKeys = _this3.parentRowNode.getGroupKeys();
+
+        var level = _this3.level;
+        var id = getRowIdFunc({
+          data: data,
+          parentKeys: parentKeys.length > 0 ? parentKeys : undefined,
+          level: level
+        });
+        var foundNode = nodesToRecycle[id];
+
+        if (!foundNode) {
+          return undefined;
+        }
+
+        delete nodesToRecycle[id];
+        return foundNode;
+      };
+
+      var recycleNode = function recycleNode(rowNode, dataItem) {
+        _this3.allNodesMap[rowNode.id] = rowNode;
+
+        _this3.blockUtils.updateDataIntoRowNode(rowNode, dataItem);
+
+        _this3.allRowNodes.push(rowNode);
+      };
+
+      rowData.forEach(function (dataItem) {
+        var nodeToRecycle = lookupNodeToRecycle(dataItem);
+
+        if (nodeToRecycle) {
+          recycleNode(nodeToRecycle, dataItem);
+        } else {
+          _this3.createDataNode(dataItem);
+        }
+      });
+    }
+  }, {
+    key: "flushAsyncTransactions",
+    value: function flushAsyncTransactions() {
+      var _this4 = this;
+
+      // we want to update the store with any outstanding transactions straight away,
+      // as otherwise if waitTimeMillis is large (eg 5s), then the user could be looking
+      // at old data for a few seconds before the transactions is applied, which isn't what
+      // you would expect when we advertise 'transaction is applied when data is loaded'.
+      // we do this in a timeout as flushAsyncTransactions expects the grid to be in a settled
+      // state, not in the middle of loading rows! keeps the VM Turns more simple and deterministic.
+      window.setTimeout(function () {
+        return _this4.transactionManager.flushAsyncTransactions();
+      }, 0);
+    }
+  }, {
+    key: "filterAndSortNodes",
+    value: function filterAndSortNodes() {
+      this.filterRowNodes();
+      this.sortRowNodes();
+    }
+  }, {
+    key: "sortRowNodes",
+    value: function sortRowNodes() {
+      var serverIsSorting = this.gridOptionsWrapper.isServerSideSortAllLevels() || this.gridOptionsWrapper.isServerSideSortOnServer();
+      var sortOptions = this.sortController.getSortOptions();
+      var noSortApplied = !sortOptions || sortOptions.length == 0;
+
+      if (serverIsSorting || noSortApplied) {
+        this.nodesAfterSort = this.nodesAfterFilter;
+        return;
+      }
+
+      this.nodesAfterSort = this.rowNodeSorter.doFullSort(this.nodesAfterFilter, sortOptions);
+    }
+  }, {
+    key: "filterRowNodes",
+    value: function filterRowNodes() {
+      var _this5 = this;
+
+      var serverIsFiltering = this.gridOptionsWrapper.isServerSideFilterAllLevels() || this.gridOptionsWrapper.isServerSideFilterOnServer(); // filtering for InFullStore only works at lowest level details.
+      // reason is the logic for group filtering was to difficult to work out how it should work at time of writing.
+
+      var groupLevel = this.groupLevel;
+
+      if (serverIsFiltering || groupLevel) {
+        this.nodesAfterFilter = this.allRowNodes;
+        return;
+      }
+
+      this.nodesAfterFilter = this.allRowNodes.filter(function (rowNode) {
+        return _this5.filterManager.doesRowPassFilter({
+          rowNode: rowNode
+        });
+      });
+    }
+  }, {
+    key: "clearDisplayIndexes",
+    value: function clearDisplayIndexes() {
+      var _this6 = this;
+
+      this.displayIndexStart = undefined;
+      this.displayIndexEnd = undefined;
+      this.allRowNodes.forEach(function (rowNode) {
+        return _this6.blockUtils.clearDisplayIndex(rowNode);
+      });
+    }
+  }, {
+    key: "getDisplayIndexEnd",
+    value: function getDisplayIndexEnd() {
+      return this.displayIndexEnd;
+    }
+  }, {
+    key: "isDisplayIndexInStore",
+    value: function isDisplayIndexInStore(displayIndex) {
+      if (this.getRowCount() === 0) {
+        return false;
+      }
+
+      return displayIndex >= this.displayIndexStart && displayIndex < this.displayIndexEnd;
+    }
+  }, {
+    key: "setDisplayIndexes",
+    value: function setDisplayIndexes(displayIndexSeq, nextRowTop) {
+      var _this7 = this;
+
+      this.displayIndexStart = displayIndexSeq.peek();
+      this.topPx = nextRowTop.value;
+      var visibleNodeIds = {}; // set on all visible nodes
+
+      this.nodesAfterSort.forEach(function (rowNode) {
+        _this7.blockUtils.setDisplayIndex(rowNode, displayIndexSeq, nextRowTop);
+
+        visibleNodeIds[rowNode.id] = true;
+      }); // and clear on all non-visible nodes
+
+      this.allRowNodes.forEach(function (rowNode) {
+        if (!visibleNodeIds[rowNode.id]) {
+          _this7.blockUtils.clearDisplayIndex(rowNode);
+        }
+      });
+      this.displayIndexEnd = displayIndexSeq.peek();
+      this.heightPx = nextRowTop.value - this.topPx;
+    }
+  }, {
+    key: "forEachNodeDeep",
+    value: function forEachNodeDeep(callback) {
+      var sequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new NumberSequence();
+      this.allRowNodes.forEach(function (rowNode) {
+        callback(rowNode, sequence.next());
+        var childCache = rowNode.childStore;
+
+        if (childCache) {
+          childCache.forEachNodeDeep(callback, sequence);
+        }
+      });
+    }
+  }, {
+    key: "forEachNodeDeepAfterFilterAndSort",
+    value: function forEachNodeDeepAfterFilterAndSort(callback) {
+      var sequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new NumberSequence();
+      this.nodesAfterSort.forEach(function (rowNode) {
+        callback(rowNode, sequence.next());
+        var childCache = rowNode.childStore;
+
+        if (childCache) {
+          childCache.forEachNodeDeepAfterFilterAndSort(callback, sequence);
+        }
+      });
+    }
+  }, {
+    key: "getRowUsingDisplayIndex",
+    value: function getRowUsingDisplayIndex(displayRowIndex) {
+      // this can happen if asking for a row that doesn't exist in the model,
+      // eg if a cell range is selected, and the user filters so rows no longer exists
+      if (!this.isDisplayIndexInStore(displayRowIndex)) {
+        return undefined;
+      }
+
+      var res = this.blockUtils.binarySearchForDisplayIndex(displayRowIndex, this.nodesAfterSort);
+      return res;
+    }
+  }, {
+    key: "getRowBounds",
+    value: function getRowBounds(index) {
+      for (var i = 0; i < this.nodesAfterSort.length; i++) {
+        var rowNode = this.nodesAfterSort[i];
+        var res = this.blockUtils.extractRowBounds(rowNode, index);
+
+        if (res) {
+          return res;
+        }
+      }
+
+      return null;
+    }
+  }, {
+    key: "isPixelInRange",
+    value: function isPixelInRange(pixel) {
+      return pixel >= this.topPx && pixel < this.topPx + this.heightPx;
+    }
+  }, {
+    key: "getRowIndexAtPixel",
+    value: function getRowIndexAtPixel(pixel) {
+      var _this8 = this;
+
+      // if pixel before block, return first row
+      var pixelBeforeThisStore = pixel <= this.topPx;
+
+      if (pixelBeforeThisStore) {
+        var firstNode = this.nodesAfterSort[0];
+        return firstNode.rowIndex;
+      } // if pixel after store, return last row, however the last
+      // row could be a child store
+
+
+      var pixelAfterThisStore = pixel >= this.topPx + this.heightPx;
+
+      if (pixelAfterThisStore) {
+        var lastRowNode = this.nodesAfterSort[this.nodesAfterSort.length - 1];
+        var lastRowNodeBottomPx = lastRowNode.rowTop + lastRowNode.rowHeight;
+
+        if (pixel >= lastRowNodeBottomPx && lastRowNode.expanded) {
+          if (lastRowNode.childStore && lastRowNode.childStore.getRowCount() > 0) {
+            return lastRowNode.childStore.getRowIndexAtPixel(pixel);
+          }
+
+          if (lastRowNode.detailNode) {
+            return lastRowNode.detailNode.rowIndex;
+          }
+        }
+
+        return lastRowNode.rowIndex;
+      }
+
+      var res = null;
+      this.nodesAfterSort.forEach(function (rowNode) {
+        var res2 = _this8.blockUtils.getIndexAtPixel(rowNode, pixel);
+
+        if (res2 != null) {
+          res = res2;
+        }
+      });
+      var pixelIsPastLastRow = res == null;
+
+      if (pixelIsPastLastRow) {
+        return this.displayIndexEnd - 1;
+      }
+
+      return res;
+    }
+  }, {
+    key: "getChildStore",
+    value: function getChildStore(keys) {
+      var _this9 = this;
+
+      return this.storeUtils.getChildStore(keys, this, function (key) {
+        var rowNode = _this9.allRowNodes.find(function (currentRowNode) {
+          return currentRowNode.key == key;
+        });
+
+        return rowNode;
+      });
+    }
+  }, {
+    key: "forEachChildStoreShallow",
+    value: function forEachChildStoreShallow(callback) {
+      this.allRowNodes.forEach(function (rowNode) {
+        var childStore = rowNode.childStore;
+
+        if (childStore) {
+          callback(childStore);
+        }
+      });
+    }
+  }, {
+    key: "refreshAfterFilter",
+    value: function refreshAfterFilter(params) {
+      var serverIsFiltering = this.gridOptionsWrapper.isServerSideFilterOnServer();
+      var storeIsImpacted = this.storeUtils.isServerRefreshNeeded(this.parentRowNode, this.ssrmParams.rowGroupCols, params);
+      var serverIsFilteringAllLevels = this.gridOptionsWrapper.isServerSideFilterAllLevels();
+
+      if (serverIsFilteringAllLevels || serverIsFiltering && storeIsImpacted) {
+        this.refreshStore(true);
+        this.sortRowNodes();
+        return;
+      }
+
+      this.filterRowNodes();
+      this.sortRowNodes();
+      this.forEachChildStoreShallow(function (store) {
+        return store.refreshAfterFilter(params);
+      });
+    }
+  }, {
+    key: "refreshAfterSort",
+    value: function refreshAfterSort(params) {
+      var serverIsSorting = this.gridOptionsWrapper.isServerSideSortOnServer();
+      var storeIsImpacted = this.storeUtils.isServerRefreshNeeded(this.parentRowNode, this.ssrmParams.rowGroupCols, params);
+      var serverIsSortingAllLevels = this.gridOptionsWrapper.isServerSideSortAllLevels();
+
+      if (serverIsSortingAllLevels || serverIsSorting && storeIsImpacted) {
+        this.refreshStore(true);
+        this.filterRowNodes();
+        return;
+      }
+
+      this.filterRowNodes();
+      this.sortRowNodes();
+      this.forEachChildStoreShallow(function (store) {
+        return store.refreshAfterSort(params);
+      });
+    }
+  }, {
+    key: "applyTransaction",
+    value: function applyTransaction(transaction) {
+      // we only apply transactions to loaded state
+      switch (this.getState()) {
+        case RowNodeBlock.STATE_FAILED:
+          return {
+            status: ServerSideTransactionResultStatus.StoreLoadingFailed
+          };
+
+        case RowNodeBlock.STATE_LOADING:
+          return {
+            status: ServerSideTransactionResultStatus.StoreLoading
+          };
+
+        case RowNodeBlock.STATE_WAITING_TO_LOAD:
+          return {
+            status: ServerSideTransactionResultStatus.StoreWaitingToLoad
+          };
+      }
+
+      var applyCallback = this.gridOptionsWrapper.getIsApplyServerSideTransactionFunc();
+
+      if (applyCallback) {
+        var params = {
+          transaction: transaction,
+          parentNode: this.parentRowNode,
+          storeInfo: this.info,
+          groupLevelInfo: this.info
+        };
+        var apply = applyCallback(params);
+
+        if (!apply) {
+          return {
+            status: ServerSideTransactionResultStatus.Cancelled
+          };
+        }
+      }
+
+      var res = {
+        status: ServerSideTransactionResultStatus.Applied,
+        remove: [],
+        update: [],
+        add: []
+      };
+      var nodesToUnselect = [];
+      this.executeAdd(transaction, res);
+      this.executeRemove(transaction, res, nodesToUnselect);
+      this.executeUpdate(transaction, res, nodesToUnselect);
+      this.filterAndSortNodes();
+      this.updateSelection(nodesToUnselect);
+      return res;
+    }
+  }, {
+    key: "updateSelection",
+    value: function updateSelection(nodesToUnselect) {
+      var selectionChanged = nodesToUnselect.length > 0;
+
+      if (selectionChanged) {
+        nodesToUnselect.forEach(function (rowNode) {
+          rowNode.setSelected(false, false, true);
+        });
+        var event = {
+          type: Events.EVENT_SELECTION_CHANGED
+        };
+        this.eventService.dispatchEvent(event);
+      }
+    }
+  }, {
+    key: "executeAdd",
+    value: function executeAdd(rowDataTran, rowNodeTransaction) {
+      var _this10 = this;
+
+      var add = rowDataTran.add,
+          addIndex = rowDataTran.addIndex;
+
+      if (_.missingOrEmpty(add)) {
+        return;
+      }
+
+      var useIndex = typeof addIndex === 'number' && addIndex >= 0;
+
+      if (useIndex) {
+        // items get inserted in reverse order for index insertion
+        add.reverse().forEach(function (item) {
+          var newRowNode = _this10.createDataNode(item, addIndex);
+
+          rowNodeTransaction.add.push(newRowNode);
+        });
+      } else {
+        add.forEach(function (item) {
+          var newRowNode = _this10.createDataNode(item);
+
+          rowNodeTransaction.add.push(newRowNode);
+        });
+      }
+    }
+  }, {
+    key: "executeRemove",
+    value: function executeRemove(rowDataTran, rowNodeTransaction, nodesToUnselect) {
+      var _this11 = this;
+
+      var remove = rowDataTran.remove;
+
+      if (remove == null) {
+        return;
+      }
+
+      var rowIdsRemoved = {};
+      remove.forEach(function (item) {
+        var rowNode = _this11.lookupRowNode(item);
+
+        if (!rowNode) {
+          return;
+        } // do delete - setting 'suppressFinishActions = true' to ensure EVENT_SELECTION_CHANGED is not raised for
+        // each row node updated, instead it is raised once by the calling code if any selected nodes exist.
+
+
+        if (rowNode.isSelected()) {
+          nodesToUnselect.push(rowNode);
+        } // so row renderer knows to fade row out (and not reposition it)
+
+
+        rowNode.clearRowTopAndRowIndex(); // NOTE: were we could remove from allLeaveChildren, however _.removeFromArray() is expensive, especially
+        // if called multiple times (eg deleting lots of rows) and if allLeafChildren is a large list
+
+        rowIdsRemoved[rowNode.id] = true; // _.removeFromArray(this.rootNode.allLeafChildren, rowNode);
+
+        delete _this11.allNodesMap[rowNode.id];
+        rowNodeTransaction.remove.push(rowNode);
+
+        _this11.nodeManager.removeNode(rowNode);
+      });
+      this.allRowNodes = this.allRowNodes.filter(function (rowNode) {
+        return !rowIdsRemoved[rowNode.id];
+      });
+    }
+  }, {
+    key: "executeUpdate",
+    value: function executeUpdate(rowDataTran, rowNodeTransaction, nodesToUnselect) {
+      var _this12 = this;
+
+      var update = rowDataTran.update;
+
+      if (update == null) {
+        return;
+      }
+
+      update.forEach(function (item) {
+        var rowNode = _this12.lookupRowNode(item);
+
+        if (!rowNode) {
+          return;
+        }
+
+        rowNode.updateData(item);
+
+        if (!rowNode.selectable && rowNode.isSelected()) {
+          nodesToUnselect.push(rowNode);
+        }
+
+        rowNodeTransaction.update.push(rowNode);
+      });
+    }
+  }, {
+    key: "lookupRowNode",
+    value: function lookupRowNode(data) {
+      var getRowIdFunc = this.gridOptionsWrapper.getRowIdFunc();
+      var rowNode;
+
+      if (getRowIdFunc != null) {
+        // find rowNode using id
+        var level = this.level;
+        var parentKeys = this.parentRowNode.getGroupKeys();
+        var id = getRowIdFunc({
+          data: data,
+          parentKeys: parentKeys.length > 0 ? parentKeys : undefined,
+          level: level
+        });
+        rowNode = this.allNodesMap[id];
+
+        if (!rowNode) {
+          console.error("AG Grid: could not find row id=".concat(id, ", data item was not found for this id"));
+          return null;
+        }
+      } else {
+        // find rowNode using object references
+        rowNode = this.allRowNodes.find(function (currentRowNode) {
+          return currentRowNode.data === data;
+        });
+
+        if (!rowNode) {
+          console.error("AG Grid: could not find data item as object was not found", data);
+          return null;
+        }
+      }
+
+      return rowNode;
+    }
+  }, {
+    key: "addStoreStates",
+    value: function addStoreStates(result) {
+      result.push({
+        infiniteScroll: false,
+        route: this.parentRowNode.getGroupKeys(),
+        rowCount: this.allRowNodes.length,
+        info: this.info
+      });
+      this.forEachChildStoreShallow(function (childStore) {
+        return childStore.addStoreStates(result);
+      });
+    }
+  }, {
+    key: "refreshStore",
+    value: function refreshStore(purge) {
+      if (purge) {
+        var loadingRowsToShow = this.nodesAfterSort ? this.nodesAfterSort.length : 1;
+        this.initialiseRowNodes(loadingRowsToShow);
+      }
+
+      this.scheduleLoad();
+      this.fireStoreUpdatedEvent();
+    }
+  }, {
+    key: "retryLoads",
+    value: function retryLoads() {
+      if (this.getState() === RowNodeBlock.STATE_FAILED) {
+        this.initialiseRowNodes(1);
+        this.scheduleLoad();
+      }
+
+      this.forEachChildStoreShallow(function (store) {
+        return store.retryLoads();
+      });
+    }
+  }, {
+    key: "scheduleLoad",
+    value: function scheduleLoad() {
+      this.setStateWaitingToLoad();
+      this.rowNodeBlockLoader.checkBlockToLoad();
+    } // gets called 1) row count changed 2) cache purged 3) items inserted
+
+  }, {
+    key: "fireStoreUpdatedEvent",
+    value: function fireStoreUpdatedEvent() {
+      // this results in row model firing ModelUpdated.
+      // server side row model also updates the row indexes first
+      var event = {
+        type: Events.EVENT_STORE_UPDATED
+      };
+      this.eventService.dispatchEvent(event);
+    }
+  }, {
+    key: "getRowCount",
+    value: function getRowCount() {
+      return this.nodesAfterSort.length;
+    }
+  }, {
+    key: "getTopLevelRowDisplayedIndex",
+    value: function getTopLevelRowDisplayedIndex(topLevelIndex) {
+      var rowNode = this.nodesAfterSort[topLevelIndex];
+      return rowNode.rowIndex;
+    }
+  }, {
+    key: "isLastRowIndexKnown",
+    value: function isLastRowIndexKnown() {
+      return this.getState() == RowNodeBlock.STATE_LOADED;
+    }
+  }, {
+    key: "getRowNodesInRange",
+    value: function getRowNodesInRange(firstInRange, lastInRange) {
+      var result = [];
+      var inActiveRange = false; // if only one node passed, we start the selection at the top
+
+      if (_.missing(firstInRange)) {
+        inActiveRange = true;
+      }
+
+      this.nodesAfterSort.forEach(function (rowNode) {
+        var hitFirstOrLast = rowNode === firstInRange || rowNode === lastInRange;
+
+        if (inActiveRange || hitFirstOrLast) {
+          result.push(rowNode);
+        }
+
+        if (hitFirstOrLast) {
+          inActiveRange = !inActiveRange;
+        }
+      }); // inActiveRange will be still true if we never hit the second rowNode
+
+      var invalidRange = inActiveRange;
+      return invalidRange ? [] : result;
+    }
+  }]);
+
+  return FullStore;
+}(RowNodeBlock);
+
+__decorate([Autowired('ssrmStoreUtils')], FullStore.prototype, 'storeUtils', void 0);
+
+__decorate([Autowired('ssrmBlockUtils')], FullStore.prototype, 'blockUtils', void 0);
+
+__decorate([Autowired('columnModel')], FullStore.prototype, 'columnModel', void 0);
+
+__decorate([Autowired('rowNodeBlockLoader')], FullStore.prototype, 'rowNodeBlockLoader', void 0);
+
+__decorate([Autowired('rowNodeSorter')], FullStore.prototype, 'rowNodeSorter', void 0);
+
+__decorate([Autowired('sortController')], FullStore.prototype, 'sortController', void 0);
+
+__decorate([Autowired('ssrmNodeManager')], FullStore.prototype, 'nodeManager', void 0);
+
+__decorate([Autowired('filterManager')], FullStore.prototype, 'filterManager', void 0);
+
+__decorate([Autowired('ssrmTransactionManager')], FullStore.prototype, 'transactionManager', void 0);
+
+__decorate([PostConstruct], FullStore.prototype, 'postConstruct', null);
+
+__decorate([PreDestroy], FullStore.prototype, 'destroyRowNodes', null);