vscroll 1.4.2 → 1.4.3

package/dist/bundles/vscroll.umd.js

@@ -1,6 +1,6 @@
 /**
  * vscroll (https://github.com/dhilt/vscroll) UMD
- * Version: 1.4.2 (2021-11-15T04:26:47.079Z)
+ * Version: 1.4.3 (2021-11-30T02:54:04.845Z)
  * Author: Denis Hilt
  * License: MIT
  */
@@ -94,7 +94,7 @@
 
     /**
      * vscroll (https://github.com/dhilt/vscroll) FESM5
-     * Version: 1.4.2 (2021-11-15T04:26:41.052Z)
+     * Version: 1.4.3 (2021-11-30T02:54:00.541Z)
      * Author: Denis Hilt
      * License: MIT
      */
@@ -435,7 +435,7 @@
 
     var core = {
       name: 'vscroll',
-      version: '1.4.2'
+      version: '1.4.3'
     };
 
     var instanceCount$1 = 0;
@@ -1442,10 +1442,10 @@
         return _super !== null && _super.apply(this, arguments) || this;
       }
       Init.run = function (scroller, process) {
-        var cycle = scroller.state.cycle, workflow = scroller.workflow;
+        var state = scroller.state, workflow = scroller.workflow;
         var isInitial = initProcesses.includes(process);
         scroller.logger.logCycle(true);
-        cycle.start(isInitial, process);
+        state.startWorkflowCycle(isInitial, process);
         workflow.call({
           process: Init.process,
           status: ProcessStatus.next
@@ -1471,16 +1471,16 @@
         });
       };
       Scroll.onSynthetic = function (scroller, position) {
-        var scrollState = scroller.state.scrollState;
-        var synthPos = scrollState.syntheticPosition;
+        var scroll = scroller.state.scroll;
+        var synthPos = scroll.syntheticPosition;
         if (synthPos !== null) {
-          if (scrollState.syntheticFulfill) {
-            scrollState.syntheticPosition = null;
+          if (scroll.syntheticFulfill) {
+            scroll.syntheticPosition = null;
           }
-          if (!scrollState.syntheticFulfill || synthPos === position) {
+          if (!scroll.syntheticFulfill || synthPos === position) {
             scroller.logger.log(function () { return [
               'skipping scroll', position,
-              "[" + (scrollState.syntheticFulfill ? '' : 'pre-') + "synthetic]"
+              "[" + (scroll.syntheticFulfill ? '' : 'pre-') + "synthetic]"
             ]; });
             return true;
           }
@@ -1491,13 +1491,13 @@
         return false;
       };
       Scroll.onThrottle = function (scroller, position, done) {
-        var scrollState = scroller.state.scrollState, throttle = scroller.settings.throttle, logger = scroller.logger;
-        scrollState.current = Scroll.getScrollEvent(position, scrollState.previous);
-        var _a = scrollState.current, direction = _a.direction, time = _a.time;
-        var timeDiff = scrollState.previous ? time - scrollState.previous.time : Infinity;
+        var scroll = scroller.state.scroll, throttle = scroller.settings.throttle, logger = scroller.logger;
+        scroll.current = Scroll.getScrollEvent(position, scroll.previous);
+        var _a = scroll.current, direction = _a.direction, time = _a.time;
+        var timeDiff = scroll.previous ? time - scroll.previous.time : Infinity;
         var delta = throttle - timeDiff;
         var shouldDelay = isFinite(delta) && delta > 0;
-        var alreadyDelayed = !!scrollState.scrollTimer;
+        var alreadyDelayed = !!scroll.scrollTimer;
         logger.log(function () { return [
           direction === exports.Direction.backward ? '\u2934' : '\u2935',
           position,
@@ -1505,17 +1505,17 @@
           shouldDelay ? (alreadyDelayed ? 'delayed' : "/ " + delta + "ms delay") : ''
         ]; });
         if (!shouldDelay) {
-          if (scrollState.scrollTimer) {
-            clearTimeout(scrollState.scrollTimer);
-            scrollState.scrollTimer = null;
+          if (scroll.scrollTimer) {
+            clearTimeout(scroll.scrollTimer);
+            scroll.scrollTimer = null;
           }
           done();
           return;
         }
         if (!alreadyDelayed) {
-          scrollState.scrollTimer = setTimeout(function () {
+          scroll.scrollTimer = setTimeout(function () {
             logger.log(function () {
-              var curr = Scroll.getScrollEvent(scroller.viewport.scrollPosition, scrollState.current);
+              var curr = Scroll.getScrollEvent(scroller.viewport.scrollPosition, scroll.current);
               return [
                 curr.direction === exports.Direction.backward ? '\u2934' : '\u2935',
                 curr.position,
@@ -1524,7 +1524,7 @@
                 position
               ];
             });
-            scrollState.scrollTimer = null;
+            scroll.scrollTimer = null;
             done();
           }, delta);
         }
@@ -1543,11 +1543,11 @@
         return { position: position, direction: direction, time: time };
       };
       Scroll.onScroll = function (scroller, workflow) {
-        var _a = scroller.state, scrollState = _a.scrollState, cycle = _a.cycle;
-        scrollState.previous = __assign({}, scrollState.current);
-        scrollState.current = null;
+        var _a = scroller.state, scroll = _a.scroll, cycle = _a.cycle;
+        scroll.previous = __assign({}, scroll.current);
+        scroll.current = null;
         if (cycle.busy.get()) {
-          scroller.logger.log(function () { return ['skipping scroll', scrollState.previous.position, '[pending]']; });
+          scroller.logger.log(function () { return ['skipping scroll', scroll.previous.position, '[pending]']; });
           return;
         }
         workflow.call({
@@ -1608,7 +1608,7 @@
         viewport.reset(buffer.startIndex);
         var payload = {};
         if (state.cycle.busy.get()) {
-          state.scrollState.stop();
+          state.scroll.stop();
           payload.finalize = true;
           state.cycle.interrupter = Reload.process;
         }
@@ -2463,9 +2463,9 @@
           }
         }
         else {
-          var _b = scroller.state, scrollState = _b.scrollState, fetch_1 = _b.fetch, viewport = scroller.viewport;
-          if (scrollState.positionBeforeAsync === null) {
-            scrollState.positionBeforeAsync = viewport.scrollPosition;
+          var _b = scroller.state, scroll_1 = _b.scroll, fetch_1 = _b.fetch, viewport = scroller.viewport;
+          if (scroll_1.positionBeforeAsync === null) {
+            scroll_1.positionBeforeAsync = viewport.scrollPosition;
           }
           fetch_1.cancel = function () {
             box.success = function () { return null; };
@@ -2597,10 +2597,10 @@
         return _super !== null && _super.apply(this, arguments) || this;
       }
       Render.run = function (scroller) {
-        var workflow = scroller.workflow, _a = scroller.state, cycle = _a.cycle, render = _a.render, scrollState = _a.scrollState, viewport = scroller.viewport, routines = scroller.routines;
+        var workflow = scroller.workflow, _a = scroller.state, cycle = _a.cycle, render = _a.render, scroll = _a.scroll, viewport = scroller.viewport, routines = scroller.routines;
         scroller.logger.stat('before new items render');
-        if (scrollState.positionBeforeAsync === null) {
-          scrollState.positionBeforeAsync = viewport.scrollPosition;
+        if (scroll.positionBeforeAsync === null) {
+          scroll.positionBeforeAsync = viewport.scrollPosition;
         }
         render.cancel = routines.render(function () {
           render.cancel = null;
@@ -2652,18 +2652,92 @@
       return Render;
     }(BaseProcessFactory(CommonProcess.render)));
 
+    var isInterrupted = function (_a) {
+      var call = _a.call;
+      return !!call.interrupted;
+    };
+    var End = /** @class */ (function (_super) {
+      __extends(End, _super);
+      function End() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      End.run = function (scroller, _a) {
+        var _b = _a === void 0 ? {} : _a, error = _b.error;
+        var workflow = scroller.workflow, interrupter = scroller.state.cycle.interrupter;
+        if (!error && !interrupter) {
+          // set out params accessible via Adapter
+          End.calculateParams(scroller, workflow);
+        }
+        // explicit interruption for we don't want to go through the inner loop finalizing
+        if (isInterrupted(workflow)) {
+          workflow.call({ process: End.process, status: ProcessStatus.done });
+          return;
+        }
+        var next = End.shouldContinueRun(scroller, error);
+        scroller.state.endInnerLoop();
+        workflow.call({
+          process: End.process,
+          status: next ? ProcessStatus.next : ProcessStatus.done,
+          payload: __assign({}, (interrupter ? { process: interrupter } : {}))
+        });
+      };
+      End.calculateParams = function (scroller, workflow) {
+        var adapter = scroller.adapter, viewport = scroller.viewport, items = scroller.buffer.items;
+        if (adapter.wanted.firstVisible) {
+          var item = viewport.getEdgeVisibleItem(items, exports.Direction.backward).item;
+          if (!item || item.element !== adapter.firstVisible.element) {
+            adapter.firstVisible = item ? item.get() : EMPTY_ITEM;
+          }
+        }
+        // the workflow can be interrupter on firstVisible change
+        if (adapter.wanted.lastVisible && !isInterrupted(workflow)) {
+          var item = viewport.getEdgeVisibleItem(items, exports.Direction.forward).item;
+          if (!item || item.element !== adapter.lastVisible.element) {
+            adapter.lastVisible = item ? item.get() : EMPTY_ITEM;
+          }
+        }
+      };
+      End.shouldContinueRun = function (scroller, error) {
+        var _a = scroller.state, cycle = _a.cycle, fetch = _a.fetch, render = _a.render;
+        // Adapter.reload or Adapter.reset
+        if (cycle.interrupter) {
+          return true;
+        }
+        // critical error
+        if (error) {
+          return false;
+        }
+        // Adapter.check
+        if (fetch.simulate && fetch.isCheck && !render.noSize) {
+          return true;
+        }
+        // Adapter.remove or Adapter.update with clip
+        if (fetch.simulate && fetch.doRemove) {
+          return true;
+        }
+        // common inner loop (App start, scroll, Adapter.clip) with full fetch
+        if (!fetch.simulate && ((fetch.hasNewItems && !render.noSize) || fetch.hasAnotherPack)) {
+          return true;
+        }
+        return false;
+      };
+      return End;
+    }(BaseProcessFactory(CommonProcess.end)));
+
     var Adjust = /** @class */ (function (_super) {
       __extends(Adjust, _super);
       function Adjust() {
         return _super !== null && _super.apply(this, arguments) || this;
       }
       Adjust.run = function (scroller) {
-        var workflow = scroller.workflow, viewport = scroller.viewport, scrollState = scroller.state.scrollState;
-        scrollState.positionBeforeAdjust = viewport.scrollPosition;
+        var workflow = scroller.workflow, viewport = scroller.viewport, scroll = scroller.state.scroll;
+        scroll.positionBeforeAdjust = viewport.scrollPosition;
         Adjust.setPaddings(scroller);
-        scrollState.positionAfterAdjust = viewport.scrollPosition;
+        scroll.positionAfterAdjust = viewport.scrollPosition;
         // scroll position adjustments
         var position = Adjust.calculatePosition(scroller);
+        // additional adjustment if the position can't be reached during the initial cycle
+        Adjust.setAdditionalForwardPadding(scroller, position);
         // set new position using animation frame
         Adjust.setPosition(scroller, position, function () {
           return workflow.call({
@@ -2696,7 +2770,8 @@
         }
         // lack of items case
         var bufferSize = viewport.getScrollableSize() - forward.size - backward.size;
-        var viewportSizeDiff = viewport.getSize() - (bwdSize + bufferSize + fwdSize);
+        var scrollSize = bwdSize + bufferSize + fwdSize;
+        var viewportSizeDiff = viewport.getSize() - scrollSize;
         if (viewportSizeDiff > 0) {
           if (inverse) {
             bwdSize += viewportSizeDiff;
@@ -2713,7 +2788,7 @@
         scroller.logger.stat('after paddings adjustments');
       };
       Adjust.calculatePosition = function (scroller) {
-        var viewport = scroller.viewport, buffer = scroller.buffer, _a = scroller.state, fetch = _a.fetch, render = _a.render, scrollState = _a.scrollState;
+        var viewport = scroller.viewport, buffer = scroller.buffer, _a = scroller.state, fetch = _a.fetch, render = _a.render, scroll = _a.scroll;
         var position = viewport.paddings.backward.size;
         // increase the position to meet the expectation of the first visible item
         if (!isNaN(fetch.firstVisible.index) && !isNaN(buffer.firstIndex)) {
@@ -2736,8 +2811,8 @@
           });
         }
         // slow fetch/render case
-        if (scrollState.positionBeforeAsync !== null) {
-          var diff = render.positionBefore - scrollState.positionBeforeAsync;
+        if (scroll.positionBeforeAsync !== null) {
+          var diff = render.positionBefore - scroll.positionBeforeAsync;
           if (diff !== 0) {
             scroller.logger.log("shift position due to fetch-render difference (" + diff + ")");
             position += diff;
@@ -2749,23 +2824,47 @@
         }
         return Math.round(position);
       };
+      Adjust.setAdditionalForwardPadding = function (scroller, position) {
+        var viewport = scroller.viewport, buffer = scroller.buffer, cycle = scroller.state.cycle;
+        if (!cycle.isInitial || !End.shouldContinueRun(scroller, null)) {
+          return;
+        }
+        var diff = position - viewport.getMaxScrollPosition();
+        if (diff <= 0) {
+          return;
+        }
+        var last = buffer.getLastVisibleItem();
+        if (!last) {
+          return;
+        }
+        var size = 0;
+        var index = last.$index + 1;
+        while (size <= diff && index <= buffer.absMaxIndex) {
+          size += buffer.getSizeByIndex(index++);
+        }
+        var shift = Math.min(size, diff);
+        if (shift) {
+          viewport.paddings.forward.size += shift;
+          scroller.logger.log("increase fwd padding due to lack of items (" + diff + " -> " + shift + ")");
+        }
+      };
       Adjust.setPosition = function (scroller, position, done) {
-        var scrollState = scroller.state.scrollState, viewport = scroller.viewport, routines = scroller.routines;
-        if (!scrollState.hasPositionChanged(position)) {
+        var scroll = scroller.state.scroll, viewport = scroller.viewport, routines = scroller.routines;
+        if (!scroll.hasPositionChanged(position)) {
           return done();
         }
-        scrollState.syntheticPosition = position;
-        scrollState.syntheticFulfill = false;
-        scrollState.cancelAnimation = routines.animate(function () {
-          scrollState.cancelAnimation = null;
-          var inertiaDiff = scrollState.positionAfterAdjust - viewport.scrollPosition;
+        scroll.syntheticPosition = position;
+        scroll.syntheticFulfill = false;
+        scroll.cancelAnimation = routines.animate(function () {
+          scroll.cancelAnimation = null;
+          var inertiaDiff = scroll.positionAfterAdjust - viewport.scrollPosition;
           var diffLog = '';
           if (inertiaDiff > 0) {
             position -= inertiaDiff;
-            scrollState.syntheticPosition = position;
+            scroll.syntheticPosition = position;
             diffLog = " (-" + inertiaDiff + ")";
           }
-          scrollState.syntheticFulfill = true;
+          scroll.syntheticFulfill = true;
           viewport.scrollPosition = position;
           scroller.logger.stat('after scroll adjustment' + diffLog);
           done();
@@ -2922,76 +3021,6 @@
       return Clip;
     }(BaseProcessFactory(CommonProcess.clip)));
 
-    var isInterrupted = function (_a) {
-      var call = _a.call;
-      return !!call.interrupted;
-    };
-    var End = /** @class */ (function (_super) {
-      __extends(End, _super);
-      function End() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      End.run = function (scroller, _a) {
-        var _b = _a === void 0 ? {} : _a, error = _b.error;
-        var workflow = scroller.workflow, interrupter = scroller.state.cycle.interrupter;
-        if (!error && !interrupter) {
-          // set out params accessible via Adapter
-          End.calculateParams(scroller, workflow);
-        }
-        // explicit interruption for we don't want to go through the inner loop finalizing
-        if (isInterrupted(workflow)) {
-          workflow.call({ process: End.process, status: ProcessStatus.done });
-          return;
-        }
-        var next = End.finalizeInnerLoop(scroller, error);
-        workflow.call({
-          process: End.process,
-          status: next ? ProcessStatus.next : ProcessStatus.done,
-          payload: __assign({}, (interrupter ? { process: interrupter } : {}))
-        });
-      };
-      End.calculateParams = function (scroller, workflow) {
-        var adapter = scroller.adapter, viewport = scroller.viewport, items = scroller.buffer.items;
-        if (adapter.wanted.firstVisible) {
-          var item = viewport.getEdgeVisibleItem(items, exports.Direction.backward).item;
-          if (!item || item.element !== adapter.firstVisible.element) {
-            adapter.firstVisible = item ? item.get() : EMPTY_ITEM;
-          }
-        }
-        // the workflow can be interrupter on firstVisible change
-        if (adapter.wanted.lastVisible && !isInterrupted(workflow)) {
-          var item = viewport.getEdgeVisibleItem(items, exports.Direction.forward).item;
-          if (!item || item.element !== adapter.lastVisible.element) {
-            adapter.lastVisible = item ? item.get() : EMPTY_ITEM;
-          }
-        }
-      };
-      End.finalizeInnerLoop = function (scroller, error) {
-        var state = scroller.state, _a = scroller.state, cycle = _a.cycle, clip = _a.clip, fetch = _a.fetch;
-        var next = !!cycle.interrupter || (error ? false : End.getNext(scroller));
-        cycle.innerLoop.isInitial = false;
-        fetch.stopSimulate();
-        clip.reset(true);
-        state.endInnerLoop();
-        return next;
-      };
-      End.getNext = function (scroller) {
-        var _a = scroller.state, fetch = _a.fetch, render = _a.render;
-        if (fetch.simulate && fetch.isCheck && !render.noSize) { // Adapter.check
-          return true;
-        }
-        if (fetch.simulate && fetch.doRemove) { // Adapter.remove or Adapter.update with clip
-          return true;
-        }
-        if ( // common inner loop (App start, Scroll, Adapter.clip) accompanied by fetch
-        !fetch.simulate && ((fetch.hasNewItems && !render.noSize) || fetch.hasAnotherPack)) {
-          return true;
-        }
-        return false;
-      };
-      return End;
-    }(BaseProcessFactory(CommonProcess.end)));
-
     var Logger = /** @class */ (function () {
       function Logger(scroller, packageInfo, adapter) {
         var _this = this;
@@ -3442,7 +3471,7 @@
         this.setOffset();
         this.paddings.reset(this.getSize(), startIndex, this.offset);
         this.scrollPosition = this.paddings.backward.size || 0;
-        this.state.scrollState.reset();
+        this.state.scroll.reset();
       };
       Viewport.prototype.setPosition = function (value) {
         var oldPosition = this.scrollPosition;
@@ -3473,6 +3502,9 @@
       Viewport.prototype.getScrollableSize = function () {
         return this.routines.getSize(this.element);
       };
+      Viewport.prototype.getMaxScrollPosition = function () {
+        return this.getScrollableSize() - this.getSize();
+      };
       Viewport.prototype.getBufferPadding = function () {
         return this.getSize() * this.settings.padding;
       };
@@ -4382,6 +4414,7 @@
         configurable: true
       });
       InnerLoopModel.prototype.done = function () {
+        this.isInitial = false;
         this.count++;
         this.total++;
         this.busy.set(false);
@@ -4402,7 +4435,7 @@
         this.innerLoop = new InnerLoopModel(loopCount);
         this.interrupter = null;
         this.busy = new Reactive(false);
-        this.done(cycleCount);
+        this.end(cycleCount);
       }
       Object.defineProperty(WorkflowCycleModel.prototype, "loopId", {
         get: function () {
@@ -4418,11 +4451,6 @@
         enumerable: false,
         configurable: true
       });
-      WorkflowCycleModel.prototype.done = function (count) {
-        this.count = count;
-        this.isInitial = false;
-        this.busy.set(false);
-      };
       WorkflowCycleModel.prototype.start = function (isInitial, initiator) {
         this.isInitial = isInitial;
         this.initiator = initiator;
@@ -4431,6 +4459,11 @@
         this.interrupter = null;
         this.busy.set(true);
       };
+      WorkflowCycleModel.prototype.end = function (count) {
+        this.count = count;
+        this.isInitial = false;
+        this.busy.set(false);
+      };
       WorkflowCycleModel.prototype.dispose = function (forever) {
         if (forever) {
           // otherwise the value will be persisted during re-instantiation
@@ -4630,11 +4663,11 @@
       return RenderModel;
     }());
 
-    var ScrollState = /** @class */ (function () {
-      function ScrollState() {
+    var ScrollModel = /** @class */ (function () {
+      function ScrollModel() {
         this.reset();
       }
-      ScrollState.prototype.reset = function () {
+      ScrollModel.prototype.reset = function () {
         this.previous = null;
         this.current = null;
         this.syntheticPosition = null;
@@ -4644,7 +4677,7 @@
         this.positionAfterAdjust = null;
         this.stop();
       };
-      ScrollState.prototype.stop = function () {
+      ScrollModel.prototype.stop = function () {
         if (this.scrollTimer) {
           clearTimeout(this.scrollTimer);
           this.scrollTimer = null;
@@ -4654,12 +4687,12 @@
           this.cancelAnimation = null;
         }
       };
-      ScrollState.prototype.hasPositionChanged = function (position) {
+      ScrollModel.prototype.hasPositionChanged = function (position) {
         var before = this.positionBeforeAdjust;
         var after = this.positionAfterAdjust;
         return before === null || before !== position || after === null || after !== position;
       };
-      return ScrollState;
+      return ScrollModel;
     }());
 
     var State = /** @class */ (function () {
@@ -4671,7 +4704,7 @@
         this.fetch = new FetchModel(settings.directionPriority);
         this.clip = new ClipModel();
         this.render = new RenderModel();
-        this.scrollState = new ScrollState();
+        this.scroll = new ScrollModel();
       }
       Object.defineProperty(State.prototype, "time", {
         get: function () {
@@ -4680,20 +4713,14 @@
         enumerable: false,
         configurable: true
       });
-      State.prototype.endInnerLoop = function () {
-        var _a = this, fetch = _a.fetch, render = _a.render, cycle = _a.cycle;
-        if (fetch.cancel) {
-          fetch.cancel();
-          fetch.cancel = null;
-        }
-        if (render.cancel) {
-          render.cancel();
-          render.cancel = null;
-        }
-        cycle.innerLoop.done();
+      State.prototype.startWorkflowCycle = function (isInitial, initiator) {
+        this.cycle.start(isInitial, initiator);
+      };
+      State.prototype.endWorkflowCycle = function (count) {
+        this.cycle.end(count);
       };
       State.prototype.startInnerLoop = function () {
-        var _a = this, cycle = _a.cycle, scroll = _a.scrollState, fetch = _a.fetch, render = _a.render, clip = _a.clip;
+        var _a = this, cycle = _a.cycle, scroll = _a.scroll, fetch = _a.fetch, render = _a.render, clip = _a.clip;
         cycle.innerLoop.start();
         scroll.positionBeforeAsync = null;
         if (!fetch.simulate) {
@@ -4706,10 +4733,24 @@
           doRender: fetch.simulate && fetch.items.length > 0
         } : {}));
       };
+      State.prototype.endInnerLoop = function () {
+        var _a = this, fetch = _a.fetch, clip = _a.clip, render = _a.render, cycle = _a.cycle;
+        fetch.stopSimulate();
+        clip.reset(true);
+        if (fetch.cancel) {
+          fetch.cancel();
+          fetch.cancel = null;
+        }
+        if (render.cancel) {
+          render.cancel();
+          render.cancel = null;
+        }
+        cycle.innerLoop.done();
+      };
       State.prototype.dispose = function () {
+        this.scroll.stop();
         this.cycle.dispose();
         this.endInnerLoop();
-        this.scrollState.stop();
       };
       return State;
     }());
@@ -5584,7 +5625,7 @@
         var _a = this.scroller, state = _a.state, logger = _a.logger;
         this.cyclesDone++;
         logger.logCycle(false);
-        state.cycle.done(this.cyclesDone + 1);
+        state.endWorkflowCycle(this.cyclesDone + 1);
         this.finalize();
       };
       Workflow.prototype.dispose = function () {