vscroll 1.4.0-alpha → 1.4.0

package/dist/bundles/vscroll.esm5.js

@@ -1,6 +1,6 @@
 /**
  * vscroll (https://github.com/dhilt/vscroll) FESM5
- * Version: 1.4.0-alpha (2021-09-24T02:40:33.386Z)
+ * Version: 1.4.0 (2021-10-01T22:35:14.215Z)
  * Author: Denis Hilt
  * License: MIT
  */
@@ -343,7 +343,7 @@ var reactiveConfigStorage = new Map();
 
 var core = {
   name: 'vscroll',
-  version: '1.4.0-alpha'
+  version: '1.4.0'
 };
 
 var instanceCount$1 = 0;
@@ -1656,94 +1656,119 @@ var Update = /** @class */ (function (_super) {
   return Update;
 }(BaseAdapterProcessFactory(AdapterProcess.update)));
 
-var Append = /** @class */ (function (_super) {
-  __extends(Append, _super);
-  function Append() {
+var Insert = /** @class */ (function (_super) {
+  __extends(Insert, _super);
+  function Insert() {
     return _super !== null && _super.apply(this, arguments) || this;
   }
-  Append.run = function (scroller, _a) {
-    var process = _a.process, options = _a.options;
-    var params = Append.parseInput(scroller, options, false, process).params;
+  Insert.run = function (scroller, options) {
+    var params = Insert.parseInput(scroller, options).params;
     if (!params) {
       return;
     }
-    var buffer = scroller.buffer;
-    var items = params.items, bof = params.bof, eof = params.eof, increase = params.increase, decrease = params.decrease;
-    var prepend = process !== AdapterProcess.append;
-    var fixRight = (prepend && !increase) || (!prepend && !!decrease);
-    var next = false;
-    if ((prepend && bof && !buffer.bof.get()) || (!prepend && eof && !buffer.eof.get())) {
-      Append.doVirtual(scroller, items, prepend, fixRight);
-    }
-    else {
-      if (!buffer.size) {
-        next = Append.doEmpty(scroller, items, prepend, fixRight);
-      }
-      else {
-        next = Append.doRegular(scroller, items, prepend, fixRight);
-      }
-    }
+    var shouldInsert = Insert.doInsert(scroller, params);
     scroller.workflow.call({
-      process: Append.process,
-      status: next ? ProcessStatus.next : ProcessStatus.done
+      process: Insert.process,
+      status: shouldInsert ? ProcessStatus.next : ProcessStatus.done
     });
   };
-  Append.doVirtual = function (scroller, items, prepend, fixRight) {
-    var buffer = scroller.buffer, paddings = scroller.viewport.paddings;
-    var absIndexToken = fixRight ? 'absMinIndex' : 'absMaxIndex';
-    if (isFinite(buffer[absIndexToken])) {
-      var size = items.length * buffer.defaultSize;
-      var padding = prepend ? paddings.backward : paddings.forward;
-      padding.size += size;
-      if (prepend) {
-        buffer.prependVirtually(items.length, fixRight);
-        scroller.viewport.scrollPosition += size;
-      }
-      else {
-        buffer.appendVirtually(items.length, fixRight);
+  Insert.doInsert = function (scroller, params) {
+    if (!Insert.insertEmpty(scroller, params)) {
+      if (!Insert.insertInBuffer(scroller, params)) {
+        if (!Insert.insertVirtually(scroller, params)) {
+          return false;
+        }
       }
-      scroller.logger.log(function () { return "buffer." + [absIndexToken] + " value is set to " + buffer[absIndexToken]; });
-      scroller.logger.stat("after virtual " + (prepend ? 'prepend' : 'append'));
     }
+    return true;
   };
-  Append.doEmpty = function (scroller, items, prepend, fixRight) {
-    var buffer = scroller.buffer, fetch = scroller.state.fetch;
-    var absIndexToken = fixRight ? 'absMinIndex' : 'absMaxIndex';
-    var shift = prepend && !fixRight ? items.length - 1 : (!prepend && fixRight ? 1 - items.length : 0);
-    var bufferLimit = buffer[absIndexToken] + (fixRight ? -1 : 1) * (items.length - 1);
-    var newItems = [];
-    var startIndex = scroller.buffer[prepend ? 'minIndex' : 'maxIndex'];
-    var index = startIndex;
-    items.forEach(function (item) {
-      var newItem = new Item(index + shift, item, scroller.routines);
-      Array.prototype[prepend ? 'unshift' : 'push'].call(newItems, newItem);
-      index += (prepend ? -1 : 1);
-    });
-    if (bufferLimit !== buffer[absIndexToken]) {
-      buffer[absIndexToken] = bufferLimit;
-      scroller.logger.log(function () { return "buffer." + absIndexToken + " value is set to " + buffer[absIndexToken]; });
-    }
-    (prepend ? fetch.prepend : fetch.append).call(fetch, newItems);
-    buffer.setItems(newItems);
-    fetch.first.indexBuffer = !isNaN(buffer.firstIndex) ? buffer.firstIndex : index;
-    fetch.last.indexBuffer = !isNaN(buffer.lastIndex) ? buffer.lastIndex : index;
-    fetch.firstVisible.index = startIndex;
+  Insert.insertEmpty = function (scroller, params) {
+    var buffer = scroller.buffer, routines = scroller.routines, fetch = scroller.state.fetch;
+    if (buffer.size) {
+      return false;
+    }
+    var beforeIndex = params.beforeIndex, afterIndex = params.afterIndex, items = params.items, decrease = params.decrease;
+    if (!buffer.fillEmpty(items, beforeIndex, afterIndex, !!decrease, function (index, data) { return new Item(index, data, routines); })) {
+      return false;
+    }
+    fetch.fill(buffer.items, buffer.startIndex);
     return true;
   };
-  Append.doRegular = function (scroller, items, prepend, fixRight) {
-    var index = scroller.buffer[prepend ? 'firstIndex' : 'lastIndex'];
+  Insert.insertInBuffer = function (scroller, params) {
+    var before = params.before, after = params.after, beforeIndex = params.beforeIndex, afterIndex = params.afterIndex, items = params.items, decrease = params.decrease;
+    var indexToInsert = scroller.buffer.getIndexToInsert(before || after, beforeIndex, afterIndex);
+    if (isNaN(indexToInsert)) {
+      return false;
+    }
+    var isBackward = Number.isInteger(beforeIndex) || before;
     var updateOptions = {
       predicate: function (_a) {
         var $index = _a.$index, data = _a.data;
-        if ($index === index) {
-          return prepend ? __spreadArray(__spreadArray([], __read(items.reverse())), [data]) : __spreadArray([data], __read(items));
+        if (indexToInsert === $index) {
+          return isBackward ? __spreadArray(__spreadArray([], __read(items)), [data]) : __spreadArray([data], __read(items));
         }
         return true;
       },
-      fixRight: fixRight
+      fixRight: decrease
     };
     return Update.doUpdate(scroller, updateOptions);
   };
+  Insert.insertVirtually = function (scroller, params) {
+    var beforeIndex = params.beforeIndex, afterIndex = params.afterIndex, items = params.items, decrease = params.decrease;
+    var buffer = scroller.buffer, fetch = scroller.state.fetch, viewport = scroller.viewport;
+    var direction = Number.isInteger(beforeIndex) ? Direction.backward : Direction.forward;
+    var indexToInsert = (direction === Direction.backward ? beforeIndex : afterIndex);
+    if (!buffer.insertVirtually(items, indexToInsert, direction, !!decrease)) {
+      return false;
+    }
+    var _a = viewport.getEdgeVisibleItem(buffer.items, Direction.backward), index = _a.index, diff = _a.diff;
+    fetch.firstVisible.index = index;
+    if (!isNaN(index)) {
+      fetch.simulate = true;
+      fetch.firstVisible.delta = -buffer.getSizeByIndex(index) + diff;
+    }
+    return true;
+  };
+  return Insert;
+}(BaseAdapterProcessFactory(AdapterProcess.insert)));
+
+var Append = /** @class */ (function (_super) {
+  __extends(Append, _super);
+  function Append() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  Append.run = function (scroller, _a) {
+    var process = _a.process, options = _a.options;
+    var params = Append.parseInput(scroller, options, false, process).params;
+    if (!params) {
+      return;
+    }
+    var shouldAppend = Append.doAppend(scroller, process, params);
+    scroller.workflow.call({
+      process: Append.process,
+      status: shouldAppend ? ProcessStatus.next : ProcessStatus.done
+    });
+  };
+  Append.doAppend = function (scroller, process, params) {
+    var bof = params.bof, eof = params.eof, increase = params.increase, decrease = params.decrease;
+    var buffer = scroller.buffer;
+    var prepend = process === AdapterProcess.prepend;
+    var opposite = prepend ? !increase : decrease;
+    var beforeIndex, afterIndex, items = params.items;
+    if (prepend) {
+      beforeIndex = (bof ? buffer.absMinIndex : buffer.minIndex) + (!buffer.size ? 1 : 0);
+      items = __spreadArray([], __read(items)).reverse();
+    }
+    else {
+      afterIndex = (eof ? buffer.absMaxIndex : buffer.maxIndex) - (!buffer.size && !opposite ? 1 : 0);
+    }
+    return Insert.doInsert(scroller, {
+      items: items,
+      beforeIndex: beforeIndex,
+      afterIndex: afterIndex,
+      decrease: opposite
+    });
+  };
   return Append;
 }(BaseAdapterProcessFactory(AdapterProcess.append)));
 
@@ -1911,86 +1936,6 @@ var UserClip = /** @class */ (function (_super) {
   return UserClip;
 }(BaseAdapterProcessFactory(AdapterProcess.clip)));
 
-var Insert = /** @class */ (function (_super) {
-  __extends(Insert, _super);
-  function Insert() {
-    return _super !== null && _super.apply(this, arguments) || this;
-  }
-  Insert.run = function (scroller, options) {
-    var params = Insert.parseInput(scroller, options).params;
-    if (!params) {
-      return;
-    }
-    var shouldInsert = Insert.doInsert(scroller, params);
-    scroller.workflow.call({
-      process: Insert.process,
-      status: shouldInsert ? ProcessStatus.next : ProcessStatus.done
-    });
-  };
-  Insert.doInsert = function (scroller, params) {
-    if (!Insert.insertInBuffer(scroller, params)) {
-      if (!Insert.insertVirtually(scroller, params)) {
-        return false;
-      }
-    }
-    return true;
-  };
-  Insert.insertInBuffer = function (scroller, params) {
-    var before = params.before, after = params.after, beforeIndex = params.beforeIndex, afterIndex = params.afterIndex, items = params.items, decrease = params.decrease;
-    var index = Number.isInteger(beforeIndex) ? beforeIndex : (Number.isInteger(afterIndex) ? afterIndex : NaN);
-    var isBackward = Number.isInteger(beforeIndex) || before;
-    var method = before || after;
-    var found = scroller.buffer.items.find(function (item) {
-      return (method && method(item.get())) || (Number.isInteger(index) && index === item.$index);
-    });
-    if (!found) {
-      scroller.logger.log('no item to insert in buffer');
-      return false;
-    }
-    var indexToInsert = found.$index;
-    var updateOptions = {
-      predicate: function (_a) {
-        var $index = _a.$index, data = _a.data;
-        if (indexToInsert === $index) {
-          return isBackward ? __spreadArray(__spreadArray([], __read(items)), [data]) : __spreadArray([data], __read(items));
-        }
-        return true;
-      },
-      fixRight: decrease
-    };
-    return Update.doUpdate(scroller, updateOptions);
-  };
-  Insert.insertVirtually = function (scroller, params) {
-    var beforeIndex = params.beforeIndex, afterIndex = params.afterIndex, items = params.items, decrease = params.decrease;
-    var buffer = scroller.buffer, fetch = scroller.state.fetch, viewport = scroller.viewport;
-    var direction = Number.isInteger(beforeIndex) ? Direction.backward : Direction.forward;
-    var index = (direction === Direction.backward ? beforeIndex : afterIndex);
-    if (isNaN(fetch.firstVisible.index)) { // if in-buffer insertion did not set firstVisible
-      var _a = viewport.getEdgeVisibleItem(buffer.items, Direction.backward), index_1 = _a.index, diff = _a.diff;
-      fetch.firstVisible.index = index_1;
-      if (!isNaN(index_1)) {
-        fetch.firstVisible.delta = -buffer.getSizeByIndex(index_1) + diff;
-      }
-    }
-    if (!buffer.insertVirtually(items, index, direction, !!decrease)) {
-      return false;
-    }
-    var firstVisible = scroller.state.fetch.firstVisible;
-    if (!isNaN(firstVisible.index)) {
-      var shift = 0;
-      if (index < firstVisible.index && !decrease) {
-        shift = items.length;
-      }
-      else if (index > firstVisible.index && decrease) {
-        shift = -items.length;
-      }
-      firstVisible.index += shift;
-    }
-    return true;
-  };
-  return Insert;
-}(BaseAdapterProcessFactory(AdapterProcess.insert)));
-
 var Replace = /** @class */ (function (_super) {
   __extends(Replace, _super);
   function Replace() {
@@ -2545,7 +2490,6 @@ var PostFetch = /** @class */ (function (_super) {
     fetch.items = items.map(function (item, index) {
       return new Item(fetchIndex + index, item, scroller.routines);
     });
-    fetch.isPrepend = !!buffer.items.length && buffer.items[0].$index > fetch.items[fetch.items.length - 1].$index;
     return buffer.setItems(fetch.items);
   };
   return PostFetch;
@@ -3835,7 +3779,31 @@ var CheckBufferCall = /** @class */ (function () {
     this.context = context;
     this.logger = logger;
   }
-  CheckBufferCall.prototype.insert = function (items, index, direction) {
+  CheckBufferCall.prototype.fillEmpty = function (items, before, after) {
+    if (!items.length) {
+      this.logger.log('no items to fill the buffer; empty list');
+      return false;
+    }
+    if (!Number.isInteger(before) && !Number.isInteger(after)) {
+      this.logger.log('no items to fill the buffer; wrong indexes');
+      return false;
+    }
+    this.logger.log(function () { return "going to fill the buffer with " + items.length + " item(s)"; });
+    return true;
+  };
+  CheckBufferCall.prototype.insertInBuffer = function (predicate, before, after) {
+    var index = Number.isInteger(before) ? before : (Number.isInteger(after) ? after : NaN);
+    var found = this.context.items.find(function (item) {
+      return (predicate && predicate(item.get())) ||
+        (Number.isInteger(index) && index === item.$index);
+    });
+    if (!found) {
+      this.logger.log('no items to insert in buffer; empty predicate\'s result');
+      return NaN;
+    }
+    return found.$index;
+  };
+  CheckBufferCall.prototype.insertVirtual = function (items, index, direction) {
     if (!items.length) {
       this.logger.log('no items to insert virtually; empty list');
       return false;
@@ -4058,6 +4026,9 @@ var Buffer = /** @class */ (function () {
       return !toRemove;
     });
   };
+  Buffer.prototype.getIndexToInsert = function (predicate, before, after) {
+    return this.checkCall.insertInBuffer(predicate, before, after);
+  };
   Buffer.prototype.shiftExtremum = function (amount, fixRight) {
     if (!fixRight) {
       this.absMaxIndex += amount;
@@ -4073,24 +4044,8 @@ var Buffer = /** @class */ (function () {
       this.startIndex = this.absMinIndex;
     }
   };
-  Buffer.prototype.appendVirtually = function (count, fixRight) {
-    if (fixRight) {
-      this.items.forEach(function (item) { return item.updateIndex(item.$index - count); });
-      this.cache.shiftIndexes(-count);
-      this.items = __spreadArray([], __read(this.items));
-    }
-    this.shiftExtremum(count, fixRight);
-  };
-  Buffer.prototype.prependVirtually = function (count, fixRight) {
-    if (!fixRight) {
-      this.items.forEach(function (item) { return item.updateIndex(item.$index + count); });
-      this.cache.shiftIndexes(count);
-      this.items = __spreadArray([], __read(this.items));
-    }
-    this.shiftExtremum(count, fixRight);
-  };
   Buffer.prototype.insertVirtually = function (items, index, direction, fixRight) {
-    if (!this.checkCall.insert(items, index, direction)) {
+    if (!this.checkCall.insertVirtual(items, index, direction)) {
       return false;
     }
     var shift = 0;
@@ -4129,6 +4084,26 @@ var Buffer = /** @class */ (function () {
     }
     this.cache.removeItems(indexes, fixRight);
   };
+  Buffer.prototype.fillEmpty = function (items, beforeIndex, afterIndex, fixRight, generator) {
+    if (!this.checkCall.fillEmpty(items, beforeIndex, afterIndex)) {
+      return false;
+    }
+    var before = Number.isInteger(beforeIndex);
+    var index = (before ? beforeIndex : afterIndex);
+    var shift = (fixRight ? items.length : (before ? 1 : 0));
+    this.items = items.map(function (data, i) {
+      return generator(index + i + (!before ? 1 : 0) - shift, data);
+    });
+    this._absMinIndex = this.items[0].$index;
+    this._absMaxIndex = this.items[this.size - 1].$index;
+    if (this.startIndex <= this.absMinIndex) {
+      this.startIndex = this.absMinIndex;
+    }
+    else if (this.startIndex > this.absMaxIndex) {
+      this.startIndex = this.absMaxIndex;
+    }
+    return true;
+  };
   Buffer.prototype.updateItems = function (predicate, generator, indexToTrack, fixRight) {
     if (!this.size || Number.isNaN(this.firstIndex)) {
       return { trackedIndex: NaN, toRemove: [] };
@@ -4397,7 +4372,6 @@ var FetchModel = /** @class */ (function () {
     this.direction = null;
     this.cancel = null;
     this.simulate = false;
-    this.isPrepend = false;
     this.isCheck = false;
     this.doRemove = false;
   };
@@ -4457,22 +4431,16 @@ var FetchModel = /** @class */ (function () {
   };
   FetchModel.prototype.stopSimulate = function () {
     this.simulate = false;
-    this.isPrepend = false;
     this.isCheck = false;
     this.doRemove = false;
   };
-  FetchModel.prototype.append = function (items) {
+  FetchModel.prototype.fill = function (items, start) {
     this.startSimulate(items);
-    this.last.index = items[items.length - 1].$index;
     this.first.index = items[0].$index;
+    this.last.index = items[items.length - 1].$index;
     this.direction = Direction.forward;
-  };
-  FetchModel.prototype.prepend = function (items) {
-    this.startSimulate(items);
-    this.last.index = items[0].$index;
-    this.first.index = items[items.length - 1].$index;
-    this.direction = Direction.backward;
-    this.isPrepend = true;
+    this.firstVisible.index = start;
+    this.firstVisible.delta = 0;
   };
   FetchModel.prototype.check = function (items) {
     this.startSimulate(items);
@@ -5244,13 +5212,7 @@ var runStateMachine = function (_a) {
     case CommonProcess.start:
       switch (payload.process) {
         case AdapterProcess.append:
-        case AdapterProcess.check:
         case AdapterProcess.insert:
-          run(Render)();
-          break;
-        case AdapterProcess.remove:
-          run(Adjust)();
-          break;
         case AdapterProcess.replace:
         case AdapterProcess.update:
           if (payload.doRender) {
@@ -5260,6 +5222,12 @@ var runStateMachine = function (_a) {
             run(Adjust)();
           }
           break;
+        case AdapterProcess.check:
+          run(Render)();
+          break;
+        case AdapterProcess.remove:
+          run(Adjust)();
+          break;
         default:
           run(PreFetch)();
       }