removing via index-based applyUpdates, edge cases

Author: dhilt

src/modules/adapter.js

@@ -120,19 +120,20 @@ class Adapter {
       throw new Error('applyUpdates - ' + index + ' is not a valid index (should be an integer)');
     }
     const _index = index - this.buffer.first;
+
     // apply updates only within buffer
     if (_index >= 0 && _index < this.buffer.length) {
       this.applyUpdate(this.buffer[_index], newItems);
     }
     // out-of-buffer case: deletion may affect Paddings
-    else if(index >= this.buffer.minIndex && index <= this.buffer.maxIndex) {
+    else if(index >= this.buffer.getAbsMinIndex() && index <= this.buffer.getAbsMaxIndex()) {
       if(angular.isArray(newItems) && !newItems.length) {
         var isTop = index === this.buffer.minIndex;
         if(isTop) {
           this.buffer.incrementMinIndex();
         }
         else {
-          this.buffer.decrementMinIndex();
+          this.buffer.decrementMaxIndex();
         }
         this.viewport.removeCacheItem(index, isTop);
       }

src/modules/buffer.js

@@ -77,16 +77,16 @@ export default function ScrollBuffer(elementRoutines, bufferSize) {
       }
       // removes single item(wrapper) from the buffer
       buffer.splice(buffer.indexOf(arg1), 1);
+      if(arg1._op === 'isTop' && buffer.first === this.getAbsMinIndex()) {
+        this.incrementMinIndex();
+      }
+      else {
+        this.decrementMaxIndex();
+      }
       if(arg1._op === 'isTop') {
-        if(buffer.first === buffer.minIndex) {
-          this.incrementMinIndex();
-        }
         buffer.first++;
       }
       else {
-        if(buffer.next === buffer.maxIndex + 1) {
-          this.decrementMinIndex();
-        }
         buffer.next--;
       }
       if(!buffer.length) {
@@ -98,15 +98,31 @@ export default function ScrollBuffer(elementRoutines, bufferSize) {
     },
 
     incrementMinIndex() {
-      if(buffer.minIndex++ === buffer.minIndexUser) {
+      if(buffer.minIndexUser !== null && buffer.minIndex === buffer.minIndexUser) {
         buffer.minIndexUser++;
       }
+      buffer.minIndex++;
     },
 
-    decrementMinIndex() {
-      if(buffer.maxIndex-- <= buffer.maxIndexUser) {
+    decrementMaxIndex() {
+      if(buffer.maxIndexUser !== null && buffer.maxIndex <= buffer.maxIndexUser) {
         buffer.maxIndexUser--;
       }
+      buffer.maxIndex--;
+    },
+
+    getAbsMinIndex() {
+      if(buffer.minIndexUser !== null) {
+        return Math.min(buffer.minIndexUser, buffer.minIndex);
+      }
+      return buffer.minIndex;
+    },
+
+    getAbsMaxIndex() {
+      if(buffer.maxIndexUser !== null) {
+        return Math.max(buffer.maxIndexUser, buffer.maxIndex);
+      }
+      return buffer.maxIndex;
     },
 
     effectiveHeight(elements) {