vscroll 1.4.0-alpha → 1.4.0

package/dist/bundles/vscroll.esm6.js

@@ -1,6 +1,6 @@
 /**
  * vscroll (https://github.com/dhilt/vscroll) FESM2015
- * Version: 1.4.0-alpha (2021-09-24T02:40:35.931Z)
+ * Version: 1.4.0 (2021-10-01T22:35:16.462Z)
  * Author: Denis Hilt
  * License: MIT
  */
@@ -328,7 +328,7 @@ const reactiveConfigStorage = new Map();
 
 var core = {
   name: 'vscroll',
-  version: '1.4.0-alpha'
+  version: '1.4.0'
 };
 
 let instanceCount$1 = 0;
@@ -1535,88 +1535,108 @@ class Update extends BaseAdapterProcessFactory(AdapterProcess.update) {
   }
 }
 
-class Append extends BaseAdapterProcessFactory(AdapterProcess.append) {
-  static run(scroller, { process, options }) {
-    const { params } = Append.parseInput(scroller, options, false, process);
+class Insert extends BaseAdapterProcessFactory(AdapterProcess.insert) {
+  static run(scroller, options) {
+    const { params } = Insert.parseInput(scroller, options);
     if (!params) {
       return;
     }
-    const { buffer } = scroller;
-    const { items, bof, eof, increase, decrease } = params;
-    const prepend = process !== AdapterProcess.append;
-    const fixRight = (prepend && !increase) || (!prepend && !!decrease);
-    let 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);
-      }
-    }
+    const 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
     });
   }
-  static doVirtual(scroller, items, prepend, fixRight) {
-    const { buffer, viewport: { paddings } } = scroller;
-    const absIndexToken = fixRight ? 'absMinIndex' : 'absMaxIndex';
-    if (isFinite(buffer[absIndexToken])) {
-      const size = items.length * buffer.defaultSize;
-      const 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);
+  static doInsert(scroller, params) {
+    if (!Insert.insertEmpty(scroller, params)) {
+      if (!Insert.insertInBuffer(scroller, params)) {
+        if (!Insert.insertVirtually(scroller, params)) {
+          return false;
+        }
       }
-      scroller.logger.log(() => `buffer.${[absIndexToken]} value is set to ${buffer[absIndexToken]}`);
-      scroller.logger.stat(`after virtual ${prepend ? 'prepend' : 'append'}`);
     }
+    return true;
   }
-  static doEmpty(scroller, items, prepend, fixRight) {
-    const { buffer, state: { fetch } } = scroller;
-    const absIndexToken = fixRight ? 'absMinIndex' : 'absMaxIndex';
-    const shift = prepend && !fixRight ? items.length - 1 : (!prepend && fixRight ? 1 - items.length : 0);
-    const bufferLimit = buffer[absIndexToken] + (fixRight ? -1 : 1) * (items.length - 1);
-    const newItems = [];
-    const startIndex = scroller.buffer[prepend ? 'minIndex' : 'maxIndex'];
-    let index = startIndex;
-    items.forEach(item => {
-      const 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(() => `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;
+  static insertEmpty(scroller, params) {
+    const { buffer, routines, state: { fetch } } = scroller;
+    if (buffer.size) {
+      return false;
+    }
+    const { beforeIndex, afterIndex, items, decrease } = params;
+    if (!buffer.fillEmpty(items, beforeIndex, afterIndex, !!decrease, (index, data) => new Item(index, data, routines))) {
+      return false;
+    }
+    fetch.fill(buffer.items, buffer.startIndex);
     return true;
   }
-  static doRegular(scroller, items, prepend, fixRight) {
-    const index = scroller.buffer[prepend ? 'firstIndex' : 'lastIndex'];
+  static insertInBuffer(scroller, params) {
+    const { before, after, beforeIndex, afterIndex, items, decrease } = params;
+    const indexToInsert = scroller.buffer.getIndexToInsert(before || after, beforeIndex, afterIndex);
+    if (isNaN(indexToInsert)) {
+      return false;
+    }
+    const isBackward = Number.isInteger(beforeIndex) || before;
     const updateOptions = {
       predicate: ({ $index, data }) => {
-        if ($index === index) {
-          return prepend ? [...items.reverse(), data] : [data, ...items];
+        if (indexToInsert === $index) {
+          return isBackward ? [...items, data] : [data, ...items];
         }
         return true;
       },
-      fixRight
+      fixRight: decrease
     };
     return Update.doUpdate(scroller, updateOptions);
   }
+  static insertVirtually(scroller, params) {
+    const { beforeIndex, afterIndex, items, decrease } = params;
+    const { buffer, state: { fetch }, viewport } = scroller;
+    const direction = Number.isInteger(beforeIndex) ? Direction.backward : Direction.forward;
+    const indexToInsert = (direction === Direction.backward ? beforeIndex : afterIndex);
+    if (!buffer.insertVirtually(items, indexToInsert, direction, !!decrease)) {
+      return false;
+    }
+    const { index, diff } = viewport.getEdgeVisibleItem(buffer.items, Direction.backward);
+    fetch.firstVisible.index = index;
+    if (!isNaN(index)) {
+      fetch.simulate = true;
+      fetch.firstVisible.delta = -buffer.getSizeByIndex(index) + diff;
+    }
+    return true;
+  }
+}
+
+class Append extends BaseAdapterProcessFactory(AdapterProcess.append) {
+  static run(scroller, { process, options }) {
+    const { params } = Append.parseInput(scroller, options, false, process);
+    if (!params) {
+      return;
+    }
+    const shouldAppend = Append.doAppend(scroller, process, params);
+    scroller.workflow.call({
+      process: Append.process,
+      status: shouldAppend ? ProcessStatus.next : ProcessStatus.done
+    });
+  }
+  static doAppend(scroller, process, params) {
+    const { bof, eof, increase, decrease } = params;
+    const { buffer } = scroller;
+    const prepend = process === AdapterProcess.prepend;
+    const opposite = prepend ? !increase : decrease;
+    let beforeIndex, afterIndex, items = params.items;
+    if (prepend) {
+      beforeIndex = (bof ? buffer.absMinIndex : buffer.minIndex) + (!buffer.size ? 1 : 0);
+      items = [...items].reverse();
+    }
+    else {
+      afterIndex = (eof ? buffer.absMaxIndex : buffer.maxIndex) - (!buffer.size && !opposite ? 1 : 0);
+    }
+    return Insert.doInsert(scroller, {
+      items,
+      beforeIndex,
+      afterIndex,
+      decrease: opposite
+    });
+  }
 }
 
 class Check extends BaseAdapterProcessFactory(AdapterProcess.check) {
@@ -1762,78 +1782,6 @@ class UserClip extends BaseAdapterProcessFactory(AdapterProcess.clip) {
   }
 }
 
-class Insert extends BaseAdapterProcessFactory(AdapterProcess.insert) {
-  static run(scroller, options) {
-    const { params } = Insert.parseInput(scroller, options);
-    if (!params) {
-      return;
-    }
-    const shouldInsert = Insert.doInsert(scroller, params);
-    scroller.workflow.call({
-      process: Insert.process,
-      status: shouldInsert ? ProcessStatus.next : ProcessStatus.done
-    });
-  }
-  static doInsert(scroller, params) {
-    if (!Insert.insertInBuffer(scroller, params)) {
-      if (!Insert.insertVirtually(scroller, params)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  static insertInBuffer(scroller, params) {
-    const { before, after, beforeIndex, afterIndex, items, decrease } = params;
-    const index = Number.isInteger(beforeIndex) ? beforeIndex : (Number.isInteger(afterIndex) ? afterIndex : NaN);
-    const isBackward = Number.isInteger(beforeIndex) || before;
-    const method = before || after;
-    const found = scroller.buffer.items.find(item => (method && method(item.get())) || (Number.isInteger(index) && index === item.$index));
-    if (!found) {
-      scroller.logger.log('no item to insert in buffer');
-      return false;
-    }
-    const indexToInsert = found.$index;
-    const updateOptions = {
-      predicate: ({ $index, data }) => {
-        if (indexToInsert === $index) {
-          return isBackward ? [...items, data] : [data, ...items];
-        }
-        return true;
-      },
-      fixRight: decrease
-    };
-    return Update.doUpdate(scroller, updateOptions);
-  }
-  static insertVirtually(scroller, params) {
-    const { beforeIndex, afterIndex, items, decrease } = params;
-    const { buffer, state: { fetch }, viewport } = scroller;
-    const direction = Number.isInteger(beforeIndex) ? Direction.backward : Direction.forward;
-    const index = (direction === Direction.backward ? beforeIndex : afterIndex);
-    if (isNaN(fetch.firstVisible.index)) { // if in-buffer insertion did not set firstVisible
-      const { index, diff } = viewport.getEdgeVisibleItem(buffer.items, Direction.backward);
-      fetch.firstVisible.index = index;
-      if (!isNaN(index)) {
-        fetch.firstVisible.delta = -buffer.getSizeByIndex(index) + diff;
-      }
-    }
-    if (!buffer.insertVirtually(items, index, direction, !!decrease)) {
-      return false;
-    }
-    const { firstVisible } = scroller.state.fetch;
-    if (!isNaN(firstVisible.index)) {
-      let shift = 0;
-      if (index < firstVisible.index && !decrease) {
-        shift = items.length;
-      }
-      else if (index > firstVisible.index && decrease) {
-        shift = -items.length;
-      }
-      firstVisible.index += shift;
-    }
-    return true;
-  }
-}
-
 class Replace extends BaseAdapterProcessFactory(AdapterProcess.replace) {
   static run(scroller, options) {
     const { params } = Replace.parseInput(scroller, options);
@@ -2347,7 +2295,6 @@ class PostFetch extends BaseProcessFactory(CommonProcess.postFetch) {
       }
     }
     fetch.items = items.map((item, index) => 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);
   }
 }
@@ -3533,7 +3480,29 @@ class CheckBufferCall {
     this.context = context;
     this.logger = logger;
   }
-  insert(items, index, direction) {
+  fillEmpty(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(() => `going to fill the buffer with ${items.length} item(s)`);
+    return true;
+  }
+  insertInBuffer(predicate, before, after) {
+    const index = Number.isInteger(before) ? before : (Number.isInteger(after) ? after : NaN);
+    const found = this.context.items.find(item => (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;
+  }
+  insertVirtual(items, index, direction) {
     if (!items.length) {
       this.logger.log('no items to insert virtually; empty list');
       return false;
@@ -3700,6 +3669,9 @@ class Buffer {
   clip() {
     this.items = this.items.filter(({ toRemove }) => !toRemove);
   }
+  getIndexToInsert(predicate, before, after) {
+    return this.checkCall.insertInBuffer(predicate, before, after);
+  }
   shiftExtremum(amount, fixRight) {
     if (!fixRight) {
       this.absMaxIndex += amount;
@@ -3715,24 +3687,8 @@ class Buffer {
       this.startIndex = this.absMinIndex;
     }
   }
-  appendVirtually(count, fixRight) {
-    if (fixRight) {
-      this.items.forEach(item => item.updateIndex(item.$index - count));
-      this.cache.shiftIndexes(-count);
-      this.items = [...this.items];
-    }
-    this.shiftExtremum(count, fixRight);
-  }
-  prependVirtually(count, fixRight) {
-    if (!fixRight) {
-      this.items.forEach(item => item.updateIndex(item.$index + count));
-      this.cache.shiftIndexes(count);
-      this.items = [...this.items];
-    }
-    this.shiftExtremum(count, fixRight);
-  }
   insertVirtually(items, index, direction, fixRight) {
-    if (!this.checkCall.insert(items, index, direction)) {
+    if (!this.checkCall.insertVirtual(items, index, direction)) {
       return false;
     }
     let shift = 0;
@@ -3767,6 +3723,24 @@ class Buffer {
     }
     this.cache.removeItems(indexes, fixRight);
   }
+  fillEmpty(items, beforeIndex, afterIndex, fixRight, generator) {
+    if (!this.checkCall.fillEmpty(items, beforeIndex, afterIndex)) {
+      return false;
+    }
+    const before = Number.isInteger(beforeIndex);
+    const index = (before ? beforeIndex : afterIndex);
+    const shift = (fixRight ? items.length : (before ? 1 : 0));
+    this.items = items.map((data, i) => 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;
+  }
   updateItems(predicate, generator, indexToTrack, fixRight) {
     if (!this.size || Number.isNaN(this.firstIndex)) {
       return { trackedIndex: NaN, toRemove: [] };
@@ -4009,7 +3983,6 @@ class FetchModel {
     this.direction = null;
     this.cancel = null;
     this.simulate = false;
-    this.isPrepend = false;
     this.isCheck = false;
     this.doRemove = false;
   }
@@ -4049,22 +4022,16 @@ class FetchModel {
   }
   stopSimulate() {
     this.simulate = false;
-    this.isPrepend = false;
     this.isCheck = false;
     this.doRemove = false;
   }
-  append(items) {
+  fill(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;
-  }
-  prepend(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;
   }
   check(items) {
     this.startSimulate(items);
@@ -4768,13 +4735,7 @@ const runStateMachine = ({ input: { process, status, payload = {} }, methods: {
     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) {
@@ -4784,6 +4745,12 @@ const runStateMachine = ({ input: { process, status, payload = {} }, methods: {
             run(Adjust)();
           }
           break;
+        case AdapterProcess.check:
+          run(Render)();
+          break;
+        case AdapterProcess.remove:
+          run(Adjust)();
+          break;
         default:
           run(PreFetch)();
       }