@egjs/flicking 4.6.1 → 4.6.2

package/dist/flicking.pkgd.js

@@ -4,7 +4,7 @@ name: @egjs/flicking
 license: MIT
 author: NAVER Corp.
 repository: https://github.com/naver/egjs-flicking
-version: 4.6.1
+version: 4.6.2
 */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -8325,6 +8325,8 @@ version: 4.6.1
       };
 
       __proto.onRelease = function (ctx) {
+        var _a;
+
         var flicking = ctx.flicking,
             axesEvent = ctx.axesEvent,
             transitTo = ctx.transitTo; // Update last position to cope with Axes's animating behavior
@@ -8344,7 +8346,13 @@ version: 4.6.1
         var control = flicking.control;
         var position = axesEvent.destPos[POSITION_KEY];
         var duration = Math.max(axesEvent.duration, flicking.duration);
-        void control.moveToPosition(position, duration, axesEvent);
+
+        try {
+          void control.moveToPosition(position, duration, axesEvent);
+        } catch (err) {
+          transitTo(STATE_TYPE.IDLE);
+          axesEvent.setTo((_a = {}, _a[POSITION_KEY] = flicking.camera.position, _a), 0);
+        }
       };
 
       return DraggingState;
@@ -8420,7 +8428,11 @@ version: 4.6.1
           direction: getDirection$1(animatingContext.start, animatingContext.end),
           axesEvent: axesEvent
         }));
-        control.setActive(this._targetPanel, control.activePanel, axesEvent.isTrusted);
+        var targetPanel = this._targetPanel;
+
+        if (targetPanel) {
+          control.setActive(targetPanel, control.activePanel, axesEvent.isTrusted);
+        }
       };
 
       return AnimatingState;
@@ -9175,7 +9187,7 @@ version: 4.6.1
        */
 
 
-      __proto.updatePosition = function (_progressInPanel) {
+      __proto.updatePosition = function (progressInPanel) {
         var flicking = getFlickingAttached(this._flicking);
         var camera = flicking.camera;
         var activePanel = this._activePanel;
@@ -9551,48 +9563,41 @@ version: 4.6.1
        */
 
       __proto.moveToPosition = function (position, duration, axesEvent) {
-        return __awaiter(this, void 0, void 0, function () {
-          var flicking, camera, activeAnchor, anchorAtCamera, state, snapThreshold, posDelta, absPosDelta, snapDelta, targetAnchor;
-          return __generator(this, function (_a) {
-            flicking = getFlickingAttached(this._flicking);
-            camera = flicking.camera;
-            activeAnchor = camera.findActiveAnchor();
-            anchorAtCamera = camera.findNearestAnchor(camera.position);
-            state = flicking.control.controller.state;
+        var flicking = getFlickingAttached(this._flicking);
+        var camera = flicking.camera;
+        var activeAnchor = camera.findActiveAnchor();
+        var anchorAtCamera = camera.findNearestAnchor(camera.position);
+        var state = flicking.control.controller.state;
 
-            if (!activeAnchor || !anchorAtCamera) {
-              return [2
-              /*return*/
-              , Promise.reject(new FlickingError(MESSAGE.POSITION_NOT_REACHABLE(position), CODE.POSITION_NOT_REACHABLE))];
-            }
+        if (!activeAnchor || !anchorAtCamera) {
+          return Promise.reject(new FlickingError(MESSAGE.POSITION_NOT_REACHABLE(position), CODE.POSITION_NOT_REACHABLE));
+        }
 
-            snapThreshold = this._calcSnapThreshold(position, activeAnchor);
-            posDelta = flicking.animating ? state.delta : position - camera.position;
-            absPosDelta = Math.abs(posDelta);
-            snapDelta = axesEvent && axesEvent.delta[POSITION_KEY] !== 0 ? Math.abs(axesEvent.delta[POSITION_KEY]) : absPosDelta;
-
-            if (snapDelta >= snapThreshold && snapDelta > 0) {
-              // Move to anchor at position
-              targetAnchor = this._findSnappedAnchor(position, anchorAtCamera);
-            } else if (absPosDelta >= flicking.threshold && absPosDelta > 0) {
-              // Move to the adjacent panel
-              targetAnchor = this._findAdjacentAnchor(posDelta, anchorAtCamera);
-            } else {
-              // Restore to active panel
-              targetAnchor = anchorAtCamera;
-            }
+        var snapThreshold = this._calcSnapThreshold(position, activeAnchor);
 
-            this._triggerIndexChangeEvent(targetAnchor.panel, position, axesEvent);
+        var posDelta = flicking.animating ? state.delta : position - camera.position;
+        var absPosDelta = Math.abs(posDelta);
+        var snapDelta = axesEvent && axesEvent.delta[POSITION_KEY] !== 0 ? Math.abs(axesEvent.delta[POSITION_KEY]) : absPosDelta;
+        var targetAnchor;
 
-            return [2
-            /*return*/
-            , this._animateToPosition({
-              position: camera.clampToReachablePosition(targetAnchor.position),
-              duration: duration,
-              newActivePanel: targetAnchor.panel,
-              axesEvent: axesEvent
-            })];
-          });
+        if (snapDelta >= snapThreshold && snapDelta > 0) {
+          // Move to anchor at position
+          targetAnchor = this._findSnappedAnchor(position, anchorAtCamera);
+        } else if (absPosDelta >= flicking.threshold && absPosDelta > 0) {
+          // Move to the adjacent panel
+          targetAnchor = this._findAdjacentAnchor(posDelta, anchorAtCamera);
+        } else {
+          // Restore to active panel
+          targetAnchor = anchorAtCamera;
+        }
+
+        this._triggerIndexChangeEvent(targetAnchor.panel, position, axesEvent);
+
+        return this._animateToPosition({
+          position: camera.clampToReachablePosition(targetAnchor.position),
+          duration: duration,
+          newActivePanel: targetAnchor.panel,
+          axesEvent: axesEvent
         });
       };
 
@@ -9781,35 +9786,26 @@ version: 4.6.1
 
 
       __proto.moveToPosition = function (position, duration, axesEvent) {
-        return __awaiter(this, void 0, void 0, function () {
-          var flicking, camera, targetPos, anchorAtPosition, targetPanel;
-          return __generator(this, function (_a) {
-            flicking = getFlickingAttached(this._flicking);
-            camera = flicking.camera;
-            targetPos = camera.clampToReachablePosition(position);
-            anchorAtPosition = camera.findAnchorIncludePosition(targetPos);
+        var flicking = getFlickingAttached(this._flicking);
+        var camera = flicking.camera;
+        var targetPos = camera.clampToReachablePosition(position);
+        var anchorAtPosition = camera.findAnchorIncludePosition(targetPos);
 
-            if (!anchorAtPosition) {
-              return [2
-              /*return*/
-              , Promise.reject(new FlickingError(MESSAGE.POSITION_NOT_REACHABLE(position), CODE.POSITION_NOT_REACHABLE))];
-            }
+        if (!anchorAtPosition) {
+          return Promise.reject(new FlickingError(MESSAGE.POSITION_NOT_REACHABLE(position), CODE.POSITION_NOT_REACHABLE));
+        }
 
-            targetPanel = anchorAtPosition.panel; // Trigger only change event
+        var targetPanel = anchorAtPosition.panel; // Trigger only change event
 
-            if (targetPanel !== this._activePanel) {
-              this._triggerIndexChangeEvent(targetPanel, position, axesEvent);
-            }
+        if (targetPanel !== this._activePanel) {
+          this._triggerIndexChangeEvent(targetPanel, position, axesEvent);
+        }
 
-            return [2
-            /*return*/
-            , this._animateToPosition({
-              position: this._stopAtEdge ? targetPos : position,
-              duration: duration,
-              newActivePanel: targetPanel,
-              axesEvent: axesEvent
-            })];
-          });
+        return this._animateToPosition({
+          position: this._stopAtEdge ? targetPos : position,
+          duration: duration,
+          newActivePanel: targetPanel,
+          axesEvent: axesEvent
         });
       };
 
@@ -10007,62 +10003,56 @@ version: 4.6.1
 
 
       __proto.moveToPosition = function (position, duration, axesEvent) {
-        return __awaiter(this, void 0, void 0, function () {
-          var flicking, camera, activePanel, axesRange, indexRange, cameraRange, clampedPosition, anchorAtPosition, prevPos, isOverThreshold, adjacentAnchor, targetPos, targetPanel, anchors, firstAnchor, lastAnchor, shouldBounceToFirst, shouldBounceToLast, targetAnchor;
-          return __generator(this, function (_a) {
-            flicking = getFlickingAttached(this._flicking);
-            camera = flicking.camera;
-            activePanel = this._activePanel;
-            axesRange = this._controller.range;
-            indexRange = this._indexRange;
-            cameraRange = camera.range;
-            clampedPosition = clamp(camera.clampToReachablePosition(position), axesRange[0], axesRange[1]);
-            anchorAtPosition = camera.findAnchorIncludePosition(clampedPosition);
-
-            if (!anchorAtPosition || !activePanel) {
-              return [2
-              /*return*/
-              , Promise.reject(new FlickingError(MESSAGE.POSITION_NOT_REACHABLE(position), CODE.POSITION_NOT_REACHABLE))];
-            }
+        var flicking = getFlickingAttached(this._flicking);
+        var camera = flicking.camera;
+        var activePanel = this._activePanel;
+        var axesRange = this._controller.range;
+        var indexRange = this._indexRange;
+        var cameraRange = camera.range;
+        var clampedPosition = clamp(camera.clampToReachablePosition(position), axesRange[0], axesRange[1]);
+        var anchorAtPosition = camera.findAnchorIncludePosition(clampedPosition);
 
-            prevPos = activePanel.position;
-            isOverThreshold = Math.abs(position - prevPos) >= flicking.threshold;
-            adjacentAnchor = position > prevPos ? camera.getNextAnchor(anchorAtPosition) : camera.getPrevAnchor(anchorAtPosition);
-            anchors = camera.anchorPoints;
-            firstAnchor = anchors[0];
-            lastAnchor = anchors[anchors.length - 1];
-            shouldBounceToFirst = position <= cameraRange.min && isBetween(firstAnchor.panel.index, indexRange.min, indexRange.max);
-            shouldBounceToLast = position >= cameraRange.max && isBetween(lastAnchor.panel.index, indexRange.min, indexRange.max);
-
-            if (shouldBounceToFirst || shouldBounceToLast) {
-              targetAnchor = position < cameraRange.min ? firstAnchor : lastAnchor;
-              targetPanel = targetAnchor.panel;
-              targetPos = targetAnchor.position;
-            } else if (isOverThreshold && anchorAtPosition.position !== activePanel.position) {
-              // Move to anchor at position
-              targetPanel = anchorAtPosition.panel;
-              targetPos = anchorAtPosition.position;
-            } else if (isOverThreshold && adjacentAnchor && isBetween(adjacentAnchor.index, indexRange.min, indexRange.max)) {
-              // Move to adjacent anchor
-              targetPanel = adjacentAnchor.panel;
-              targetPos = adjacentAnchor.position;
-            } else {
-              // Restore to active panel
-              targetPos = camera.clampToReachablePosition(activePanel.position);
-              targetPanel = activePanel;
-            }
+        if (!anchorAtPosition || !activePanel) {
+          return Promise.reject(new FlickingError(MESSAGE.POSITION_NOT_REACHABLE(position), CODE.POSITION_NOT_REACHABLE));
+        }
+
+        var prevPos = activePanel.position;
+        var isOverThreshold = Math.abs(position - prevPos) >= flicking.threshold;
+        var adjacentAnchor = position > prevPos ? camera.getNextAnchor(anchorAtPosition) : camera.getPrevAnchor(anchorAtPosition);
+        var targetPos;
+        var targetPanel;
+        var anchors = camera.anchorPoints;
+        var firstAnchor = anchors[0];
+        var lastAnchor = anchors[anchors.length - 1];
+        var shouldBounceToFirst = position <= cameraRange.min && isBetween(firstAnchor.panel.index, indexRange.min, indexRange.max);
+        var shouldBounceToLast = position >= cameraRange.max && isBetween(lastAnchor.panel.index, indexRange.min, indexRange.max);
+
+        if (shouldBounceToFirst || shouldBounceToLast) {
+          // In bounce area
+          var targetAnchor = position < cameraRange.min ? firstAnchor : lastAnchor;
+          targetPanel = targetAnchor.panel;
+          targetPos = targetAnchor.position;
+        } else if (isOverThreshold && anchorAtPosition.position !== activePanel.position) {
+          // Move to anchor at position
+          targetPanel = anchorAtPosition.panel;
+          targetPos = anchorAtPosition.position;
+        } else if (isOverThreshold && adjacentAnchor && isBetween(adjacentAnchor.index, indexRange.min, indexRange.max)) {
+          // Move to adjacent anchor
+          targetPanel = adjacentAnchor.panel;
+          targetPos = adjacentAnchor.position;
+        } else {
+          // Restore to active panel
+          targetPos = camera.clampToReachablePosition(activePanel.position);
+          targetPanel = activePanel;
+        }
 
-            this._triggerIndexChangeEvent(targetPanel, position, axesEvent);
+        this._triggerIndexChangeEvent(targetPanel, position, axesEvent);
 
-            return [2
-            /*return*/
-            , this._animateToPosition({
-              position: targetPos,
-              duration: duration,
-              newActivePanel: targetPanel,
-              axesEvent: axesEvent
-            })];
-          });
+        return this._animateToPosition({
+          position: targetPos,
+          duration: duration,
+          newActivePanel: targetPanel,
+          axesEvent: axesEvent
         });
       };
 
@@ -12751,29 +12741,31 @@ version: 4.6.1
 
         void this.render();
 
-        if (!activePanel || activePanel.removed) {
-          if (panels.length <= 0) {
-            // All panels removed
-            camera.lookAt(0);
-          } else {
-            var targetIndex = (_a = activePanel === null || activePanel === void 0 ? void 0 : activePanel.index) !== null && _a !== void 0 ? _a : 0;
+        if (!flicking.animating) {
+          if (!activePanel || activePanel.removed) {
+            if (panels.length <= 0) {
+              // All panels removed
+              camera.lookAt(0);
+            } else {
+              var targetIndex = (_a = activePanel === null || activePanel === void 0 ? void 0 : activePanel.index) !== null && _a !== void 0 ? _a : 0;
 
-            if (targetIndex > panels.length - 1) {
-              targetIndex = panels.length - 1;
-            }
+              if (targetIndex > panels.length - 1) {
+                targetIndex = panels.length - 1;
+              }
 
-            void control.moveToPanel(panels[targetIndex], {
+              void control.moveToPanel(panels[targetIndex], {
+                duration: 0
+              }).catch(function () {
+                return void 0;
+              });
+            }
+          } else {
+            void control.moveToPanel(activePanel, {
               duration: 0
             }).catch(function () {
               return void 0;
             });
           }
-        } else {
-          void control.moveToPanel(control.activePanel, {
-            duration: 0
-          }).catch(function () {
-            return void 0;
-          });
         }
 
         flicking.camera.updateOffset();
@@ -15896,7 +15888,7 @@ version: 4.6.1
        */
 
 
-      Flicking.VERSION = "4.6.1";
+      Flicking.VERSION = "4.6.2";
       return Flicking;
     }(Component$1);
 
@@ -16067,7 +16059,9 @@ version: 4.6.1
         }
       }
 
-      renderer.updateAfterPanelChange(added, removed);
+      if (diffResult.added.length > 0 || diffResult.removed.length > 0) {
+        renderer.updateAfterPanelChange(added, removed);
+      }
     });
 
     var batchInsert = function (renderer, diffResult, addedElements, startIdx, endIdx) {