vscroll 1.4.2 → 1.4.3

package/dist/bundles/vscroll.esm5.js

@@ -1,6 +1,6 @@
 /**
  * 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
  */
@@ -343,7 +343,7 @@ var reactiveConfigStorage = new Map();
 
 var core = {
   name: 'vscroll',
-  version: '1.4.2'
+  version: '1.4.3'
 };
 
 var instanceCount$1 = 0;
@@ -1350,10 +1350,10 @@ var Init = /** @class */ (function (_super) {
     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
@@ -1379,16 +1379,16 @@ var Scroll = /** @class */ (function (_super) {
     });
   };
   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;
       }
@@ -1399,13 +1399,13 @@ var Scroll = /** @class */ (function (_super) {
     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 === Direction.backward ? '\u2934' : '\u2935',
       position,
@@ -1413,17 +1413,17 @@ var Scroll = /** @class */ (function (_super) {
       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 === Direction.backward ? '\u2934' : '\u2935',
             curr.position,
@@ -1432,7 +1432,7 @@ var Scroll = /** @class */ (function (_super) {
             position
           ];
         });
-        scrollState.scrollTimer = null;
+        scroll.scrollTimer = null;
         done();
       }, delta);
     }
@@ -1451,11 +1451,11 @@ var Scroll = /** @class */ (function (_super) {
     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({
@@ -1516,7 +1516,7 @@ var Reload = /** @class */ (function (_super) {
     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;
     }
@@ -2371,9 +2371,9 @@ var Fetch = /** @class */ (function (_super) {
       }
     }
     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; };
@@ -2505,10 +2505,10 @@ var Render = /** @class */ (function (_super) {
     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;
@@ -2560,18 +2560,92 @@ var Render = /** @class */ (function (_super) {
   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, 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, 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({
@@ -2604,7 +2678,8 @@ var Adjust = /** @class */ (function (_super) {
     }
     // 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;
@@ -2621,7 +2696,7 @@ var Adjust = /** @class */ (function (_super) {
     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)) {
@@ -2644,8 +2719,8 @@ var Adjust = /** @class */ (function (_super) {
       });
     }
     // 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;
@@ -2657,23 +2732,47 @@ var Adjust = /** @class */ (function (_super) {
     }
     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();
@@ -2830,76 +2929,6 @@ var Clip = /** @class */ (function (_super) {
   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, 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, 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;
@@ -3350,7 +3379,7 @@ var Viewport = /** @class */ (function () {
     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;
@@ -3381,6 +3410,9 @@ var Viewport = /** @class */ (function () {
   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;
   };
@@ -4290,6 +4322,7 @@ var InnerLoopModel = /** @class */ (function () {
     configurable: true
   });
   InnerLoopModel.prototype.done = function () {
+    this.isInitial = false;
     this.count++;
     this.total++;
     this.busy.set(false);
@@ -4310,7 +4343,7 @@ var WorkflowCycleModel = /** @class */ (function () {
     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 () {
@@ -4326,11 +4359,6 @@ var WorkflowCycleModel = /** @class */ (function () {
     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;
@@ -4339,6 +4367,11 @@ var WorkflowCycleModel = /** @class */ (function () {
     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
@@ -4538,11 +4571,11 @@ var RenderModel = /** @class */ (function () {
   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;
@@ -4552,7 +4585,7 @@ var ScrollState = /** @class */ (function () {
     this.positionAfterAdjust = null;
     this.stop();
   };
-  ScrollState.prototype.stop = function () {
+  ScrollModel.prototype.stop = function () {
     if (this.scrollTimer) {
       clearTimeout(this.scrollTimer);
       this.scrollTimer = null;
@@ -4562,12 +4595,12 @@ var ScrollState = /** @class */ (function () {
       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 () {
@@ -4579,7 +4612,7 @@ var State = /** @class */ (function () {
     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 () {
@@ -4588,20 +4621,14 @@ var State = /** @class */ (function () {
     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) {
@@ -4614,10 +4641,24 @@ var State = /** @class */ (function () {
       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;
 }());
@@ -5492,7 +5533,7 @@ var Workflow = /** @class */ (function () {
     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 () {