@egjs/flicking 4.12.0-beta.8 → 4.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@egjs/flicking",
-	"version": "4.12.0-beta.8",
+	"version": "4.12.0",
 	"description": "Everyday 30 million people experience. It's reliable, flexible and extendable carousel.",
 	"main": "dist/flicking.cjs.js",
 	"module": "dist/flicking.esm.js",
@@ -12,13 +12,12 @@
 	"types": "declaration/index.d.ts",
 	"scripts": {
 		"start": "concurrently \"rollup -w --config ./rollup.config.dev.js\" \"http-serve\"",
-		"build": "run-s build:bundle build:declaration printsizes",
-    "build-react": "run-s build:bundle build:declaration && pvu --build=react-flicking",
+		"build": "run-s build:bundle build:declaration build:css printsizes",
 		"build:bundle": "rm -rf ./dist && rollup -c",
 		"build:declaration": "rm -rf ./declaration && tsc -p tsconfig.declaration.json",
 		"build:css": "run-s build:css-clear build:sass build:css-prefix build:css-min",
 		"build:css-clear": "rm -rf ./dist/*.css",
-		"build:sass": "node-sass sass/ -o dist/ -x --output-style expanded",
+		"build:sass": "sass sass/:dist/ --style=expanded --no-source-map && sass sass/flicking.sass dist/flicking.min.css --style=compressed --no-source-map && sass sass/flicking-inline.sass dist/flicking-inline.min.css --style=compressed --no-source-map",
 		"build:css-prefix": "postcss dist/*.css --replace --use autoprefixer --no-map",
 		"build:css-min": "postcss dist/*.css --ext .min.css --use postcss-clean -d dist/ --no-map",
 		"declaration": "rm -rf declaration && tsc -p tsconfig.declaration.json",
@@ -115,7 +114,6 @@
 		"husky": "^1.3.1",
 		"jsdoc-to-mdx": "^1.1.2",
 		"karma-typescript-es6-transform": "^5.5.2",
-		"node-sass": "^7.0.1",
 		"npm-run-all": "^4.1.5",
 		"postcss-clean": "^1.2.2",
 		"postcss-cli": "^7.1.2",
@@ -130,6 +128,7 @@
 		"rollup-plugin-terser": "^7.0.2",
 		"rollup-plugin-typescript2": "^0.36.0",
 		"rollup-plugin-visualizer": "^4.2.1",
+		"sass": "^1.79.3",
 		"sync-exec": "^0.6.2",
 		"ts-mock-imports": "^1.3.3",
 		"tsconfig-paths-webpack-plugin": "^3.5.1",
@@ -140,7 +139,7 @@
 		"typescript-transform-paths": "^2.2.3"
 	},
 	"dependencies": {
-		"@egjs/axes": "^3.9.0",
+		"@egjs/axes": "^3.9.1",
 		"@egjs/component": "^3.0.1",
 		"@egjs/imready": "^1.3.1",
 		"@egjs/list-differ": "^1.0.1"

package/sass/flicking.sass

@@ -2,9 +2,16 @@
   position: relative
   overflow: hidden
   &.vertical
+    display: -webkit-inline-box
+    display: -ms-inline-flexbox
     display: inline-flex
     >.flicking-camera
+      display: -webkit-inline-box
+      display: -ms-inline-flexbox
       display: inline-flex
+      -webkit-box-orient: vertical
+      -webkit-box-direction: normal
+      -ms-flex-direction: column
       flex-direction: column
   &.flicking-hidden
     >.flicking-camera
@@ -14,10 +21,16 @@
 .flicking-camera
   width: 100%
   height: 100%
+  display: -webkit-box
+  display: -ms-flexbox
   display: flex
   position: relative
+  -webkit-box-orient: horizontal
+  -webkit-box-direction: normal
+  -ms-flex-direction: row
   flex-direction: row
   z-index: 1
   will-change: transform
   >*
+    -ms-flex-negative: 0
     flex-shrink: 0

package/src/CrossFlicking.ts

@@ -2,15 +2,49 @@
  * Copyright (c) 2015 NAVER Corp.
  * egjs projects are licensed under the MIT license
  */
-
-import Flicking, { FlickingOptions } from "./Flicking";
-import { ChangedEvent, MoveEndEvent, MoveEvent } from "./type/event";
+import { ComponentEvent } from "@egjs/component";
+import { EventKey } from "@egjs/component/declaration/types";
+
+import Flicking, { FlickingEvents, FlickingOptions } from "./Flicking";
+import {
+  ChangedEvent,
+  HoldEndEvent,
+  HoldStartEvent,
+  MoveEndEvent,
+  MoveEvent,
+  MoveStartEvent,
+  RestoredEvent,
+  WillChangeEvent,
+  WillRestoreEvent
+} from "./type/event";
 import { LiteralUnion, ValueOf } from "./type/internal";
 import { CLASS, EVENTS, MOVE_DIRECTION } from "./const/external";
 import { getDataAttributes, includes, toArray } from "./utils";
 
-export interface CrossFlickingEvents {
-  // FlickingEvent 들을 확장하자...
+export const SIDE_EVENTS = {
+  HOLD_START: "sideHoldStart",
+  HOLD_END: "sideHoldEnd",
+  MOVE_START: "sideMoveStart",
+  MOVE: "sideMove",
+  MOVE_END: "sideMoveEnd",
+  WILL_CHANGE: "sideWillChange",
+  CHANGED: "sideChanged",
+  WILL_RESTORE: "sideWillRestore",
+  RESTORED: "sideRestored"
+} as const;
+
+export type CrossFlickingEvent<T> = { mainIndex: number } & T;
+
+export interface CrossFlickingEvents extends FlickingEvents {
+  [SIDE_EVENTS.HOLD_START]: CrossFlickingEvent<HoldStartEvent>;
+  [SIDE_EVENTS.HOLD_END]: CrossFlickingEvent<HoldEndEvent>;
+  [SIDE_EVENTS.MOVE_START]: CrossFlickingEvent<MoveStartEvent>;
+  [SIDE_EVENTS.MOVE]: CrossFlickingEvent<MoveEvent>;
+  [SIDE_EVENTS.MOVE_END]: CrossFlickingEvent<MoveEndEvent>;
+  [SIDE_EVENTS.WILL_CHANGE]: CrossFlickingEvent<WillChangeEvent>;
+  [SIDE_EVENTS.CHANGED]: CrossFlickingEvent<ChangedEvent>;
+  [SIDE_EVENTS.WILL_RESTORE]: CrossFlickingEvent<WillRestoreEvent>;
+  [SIDE_EVENTS.RESTORED]: CrossFlickingEvent<RestoredEvent>;
 }
 
 export interface CrossFlickingOptions extends FlickingOptions {
@@ -27,6 +61,14 @@ export interface SideState {
   element: HTMLElement;
 }
 
+export interface CrossFlickingChangedEvent extends ChangedEvent {
+  sideIndex?: number;
+}
+
+export interface CrossFlickingWillChangeEvent extends WillChangeEvent {
+  sideIndex?: number;
+}
+
 export class CrossFlicking extends Flicking {
   // Core components
   private _sideFlicking: Flicking[];
@@ -40,6 +82,7 @@ export class CrossFlicking extends Flicking {
   // Internal State
   private _sideState: SideState[];
   private _moveDirection: LiteralUnion<ValueOf<typeof MOVE_DIRECTION>> | null;
+  private _originalDragThreshold: number;
   private _nextIndex: number;
 
   // Components
@@ -47,6 +90,10 @@ export class CrossFlicking extends Flicking {
     return this._sideFlicking;
   }
 
+  public get sideIndex() {
+    return this._sideFlicking.map(i => i.index);
+  }
+
   public get sideState() {
     return this._sideState;
   }
@@ -64,38 +111,41 @@ export class CrossFlicking extends Flicking {
   public set sideOptions(val: CrossFlickingOptions["sideOptions"]) {
     this._sideOptions = val;
   }
+
   public set preserveIndex(val: CrossFlickingOptions["preserveIndex"]) {
     this._preserveIndex = val;
   }
+
   public set disableSlideOnHold(val: CrossFlickingOptions["disableSlideOnHold"]) {
     this._disableSlideOnHold = val;
   }
+
   public set disableIndexSync(val: CrossFlickingOptions["disableIndexSync"]) {
     this._disableIndexSync = val;
   }
 
   public constructor(
     root: HTMLElement | string,
-    options: Partial<CrossFlickingOptions> = {
-      sideOptions: {},
-      preserveIndex: false,
-      disableSlideOnHold: false,
-      disableIndexSync: false,
-    }
+    options: Partial<CrossFlickingOptions>
   ) {
     super(root, options);
+    const {
+      sideOptions = {},
+      preserveIndex = true,
+      disableSlideOnHold = true,
+      disableIndexSync = false
+    } = options;
 
     // Internal states
     this._moveDirection = null;
     this._nextIndex = 0;
+    this._originalDragThreshold = this.dragThreshold;
 
     // Bind options
-    this._sideOptions = options.sideOptions;
-    this._preserveIndex = options.preserveIndex;
-    this._disableSlideOnHold = options.disableSlideOnHold;
-    this._disableIndexSync = options.disableIndexSync;
-
-    // Create core components
+    this._sideOptions = sideOptions;
+    this._preserveIndex = preserveIndex;
+    this._disableSlideOnHold = disableSlideOnHold;
+    this._disableIndexSync = disableIndexSync;
   }
 
   public init(): Promise<void> {
@@ -107,7 +157,9 @@ export class CrossFlicking extends Flicking {
   }
 
   public destroy(): void {
-    // TODO 모든 child flicking destroy
+    this._sideFlicking.forEach((flicking) => {
+      flicking.destroy();
+    });
     super.destroy();
   }
 
@@ -115,93 +167,53 @@ export class CrossFlicking extends Flicking {
     this.on(EVENTS.HOLD_START, this._onHorizontalHoldStart);
     this.on(EVENTS.MOVE, this._onHorizontalMove);
     this.on(EVENTS.MOVE_END, this._onHorizontalMoveEnd);
+    [EVENTS.CHANGED, EVENTS.WILL_CHANGE].forEach((event) => {
+      this.on(event, this._addSideIndex);
+    });
 
-    this._sideFlicking.forEach((flicking) => {
+    this._sideFlicking.forEach((flicking, mainIndex) => {
       flicking.on(EVENTS.HOLD_START, this._onSideHoldStart);
       flicking.on(EVENTS.MOVE, this._onSideMove);
       flicking.on(EVENTS.MOVE_END, this._onSideMoveEnd);
       flicking.on(EVENTS.CHANGED, this._onSideChanged);
-    });
-  }
 
-  private _getGroupFromAttribute(panels: HTMLElement[]): Record<string, HTMLElement[]> {
-    const groupKeys: string[] = [];
-    const groupPanels: Record<string, HTMLElement[]> = {};
-
-    panels.forEach((panel) => {
-      const groupKey = getDataAttributes(panel, "data-cross-").groupkey;
-      if (groupKey && !includes(groupKeys, groupKey)) {
-        groupKeys.push(groupKey);
-        groupPanels[groupKey] = [panel];
-      } else if (groupKey) {
-        groupPanels[groupKey].push(panel);
-      }
+      Object.keys(SIDE_EVENTS).forEach((name: EventKey<FlickingEvents>) => {
+        flicking.on(EVENTS[name], (event) => {
+          this.trigger(
+            new ComponentEvent(SIDE_EVENTS[name], {
+              mainIndex,
+              ...event
+            })
+          );
+        });
+      });
     });
-
-    return groupPanels;
   }
 
   private _createSideState(): SideState[] {
     const viewportEl = this.element;
     const cameraEl = this.camera.element;
     const panels = toArray(cameraEl.children) as HTMLElement[];
-    let sideState: SideState[] = [];
-    let sidePanels: string = "";
-
-    // check data attribute exists
-    const sideCamera = document.createElement("div");
-    sideCamera.classList.add(CLASS.CAMERA);
-
     const isCrossStructure = getDataAttributes(
       viewportEl,
       "data-cross-"
     ).structure;
+    let sideState: SideState[] = [];
 
     if (!isCrossStructure) {
-      viewportEl.setAttribute("data-cross-structure", "true");
-
       const groupPanels = this._getGroupFromAttribute(panels);
       const groupKeys = Object.keys(groupPanels);
 
       if (groupKeys.length) {
         sideState = this._getSideStateFromGroup(groupPanels);
         this.remove(0, this.panelCount - groupKeys.length);
-        sideState.forEach((state, i) => {
-          const panel = this.camera.children[i];
-          sidePanels += state.element.innerHTML;
-          Array.from(panel.attributes).forEach(attribute => panel.removeAttribute(attribute.name));
-        });
       } else {
-        sideState = panels.reduce(
-          (state: SideState[], panel: HTMLElement, i: number) => {
-            const start = state.length ? +state[state.length - 1].end + 1 : 0;
-            sidePanels += panel.innerHTML;
-            return [
-              ...state,
-              {
-                key: i.toString(),
-                start,
-                end: start + panel.children.length - 1,
-                element: panel,
-              },
-            ];
-          },
-          []
-        );
+        sideState = this._getSideStateFromPanels(panels);
       }
 
-      sideCamera.innerHTML = sidePanels;
-      sideState.forEach((_, i) => {
-        const panel = this.camera.children[i];
-        [CLASS.VIEWPORT, CLASS.VERTICAL].forEach((className) => {
-          if (!panel.classList.contains(className)) {
-            panel.classList.add(className);
-          }
-        });
-        panel.innerHTML = sideCamera.outerHTML;
-      });
+      this._createCrossStructure(sideState);
     } else {
-      sideState = this._getSideStateFromPanels(panels);
+      sideState = this._getSideStateFromCrossStructure(panels);
     }
 
     void this.resize();
@@ -209,7 +221,56 @@ export class CrossFlicking extends Flicking {
     return sideState;
   }
 
-  private _getSideStateFromGroup(groupPanels: Record<string, HTMLElement[]>): SideState[] {
+  private _createCrossStructure(sideState: SideState[]) {
+    const sideCamera = document.createElement("div");
+    let sidePanels: string = "";
+
+    sideCamera.classList.add(CLASS.CAMERA);
+    sideState.forEach((state, i) => {
+      const panel = this.camera.children[i];
+      sidePanels += state.element.innerHTML;
+      Array.from(panel.attributes).forEach((attribute) =>
+        panel.removeAttribute(attribute.name)
+      );
+    });
+
+    sideCamera.innerHTML = sidePanels;
+
+    sideState.forEach((_, i) => {
+      const panel = this.camera.children[i];
+      [CLASS.VIEWPORT, CLASS.VERTICAL].forEach((className) => {
+        if (!panel.classList.contains(className)) {
+          panel.classList.add(className);
+        }
+      });
+      panel.innerHTML = sideCamera.outerHTML;
+    });
+
+    this.element.setAttribute("data-cross-structure", "true");
+  }
+
+  private _getGroupFromAttribute(
+    panels: HTMLElement[]
+  ): Record<string, HTMLElement[]> {
+    const groupKeys: string[] = [];
+    const groupPanels: Record<string, HTMLElement[]> = {};
+
+    panels.forEach((panel) => {
+      const groupKey = getDataAttributes(panel, "data-cross-").groupkey;
+      if (groupKey && !includes(groupKeys, groupKey)) {
+        groupKeys.push(groupKey);
+        groupPanels[groupKey] = [panel];
+      } else if (groupKey) {
+        groupPanels[groupKey].push(panel);
+      }
+    });
+
+    return groupPanels;
+  }
+
+  private _getSideStateFromGroup(
+    groupPanels: Record<string, HTMLElement[]>
+  ): SideState[] {
     return Object.keys(groupPanels).reduce(
       (state: SideState[], key: string) => {
         const start = state.length ? +state[state.length - 1].end + 1 : 0;
@@ -235,6 +296,24 @@ export class CrossFlicking extends Flicking {
   }
 
   private _getSideStateFromPanels(panels: HTMLElement[]): SideState[] {
+    return panels.reduce(
+      (state: SideState[], panel: HTMLElement, i: number) => {
+        const start = state.length ? +state[state.length - 1].end + 1 : 0;
+        return [
+          ...state,
+          {
+            key: i.toString(),
+            start,
+            end: start + panel.children.length - 1,
+            element: panel
+          }
+        ];
+      },
+      []
+    );
+  }
+
+  private _getSideStateFromCrossStructure(panels: HTMLElement[]): SideState[] {
     const groupPanels = this._getGroupFromAttribute(panels);
     return this._getSideStateFromGroup(groupPanels);
   }
@@ -245,13 +324,16 @@ export class CrossFlicking extends Flicking {
         ...this.sideOptions,
         horizontal: false,
         panelsPerView: 1,
-        defaultIndex: state.start,
-        moveType: "strict"
+        defaultIndex: state.start
       });
     });
   }
 
-  private _syncToCategory(index: number, outerIndex: number): void {
+  private _syncToCategory = (index: number, outerIndex: number): void => {
+    if (this._disableIndexSync) {
+      return;
+    }
+
     this.stopAnimation();
     this._sideFlicking.forEach((child, i) => {
       const { start, end } = this._sideState[i];
@@ -262,18 +344,66 @@ export class CrossFlicking extends Flicking {
         void this.moveTo(i, 0);
       }
     });
-  }
+  };
+
+  private _setDraggable = (
+    direction: ValueOf<typeof MOVE_DIRECTION>,
+    draggable: boolean
+  ): void => {
+    if (!this._disableSlideOnHold) {
+      return;
+    }
+
+    const dragThreshold = this._originalDragThreshold;
+    const threshold = draggable
+      ? dragThreshold && dragThreshold >= 10
+        ? dragThreshold
+        : 10
+      : Infinity;
+
+    if ((direction === MOVE_DIRECTION.HORIZONTAL) === this.horizontal) {
+      this.dragThreshold = threshold;
+    } else if ((direction === MOVE_DIRECTION.VERTICAL) === this.horizontal) {
+      this._sideFlicking.forEach((child) => {
+        child.dragThreshold = threshold;
+      });
+    }
+  };
+
+  private _setPreviousSideIndex = () => {
+    this._sideFlicking.forEach((child, i) => {
+      const { start, end } = this._sideState[i];
+
+      if (this._preserveIndex) {
+        if (this._nextIndex !== i) {
+          if (child.index < start) {
+            child.stopAnimation();
+            void child.moveTo(start, 0);
+          } else if (child.index > end) {
+            child.stopAnimation();
+            void child.moveTo(end, 0);
+          }
+        }
+      } else {
+        if (this._nextIndex !== i) {
+          void child.moveTo(start, 0);
+        }
+      }
+    });
+  };
+
+  private _addSideIndex = (e: ChangedEvent | WillChangeEvent): void => {
+    (e as CrossFlickingChangedEvent | CrossFlickingWillChangeEvent).sideIndex = this._sideFlicking[e.index].index;
+  };
 
   private _onHorizontalHoldStart = (): void => {
-    this.dragThreshold = 10;
+    this._setDraggable(MOVE_DIRECTION.HORIZONTAL, true);
     this._moveDirection = null;
   };
 
   private _onHorizontalMove = (e: MoveEvent): void => {
     if (e.isTrusted && !this._moveDirection) {
-      this._sideFlicking.forEach((child) => {
-        child.dragThreshold = Infinity;
-      });
+      this._setDraggable(MOVE_DIRECTION.VERTICAL, false);
       this._moveDirection = MOVE_DIRECTION.HORIZONTAL;
     }
   };
@@ -281,11 +411,6 @@ export class CrossFlicking extends Flicking {
   private _onHorizontalMoveEnd = (e: MoveEndEvent): void => {
     const visiblePanels = this.visiblePanels;
 
-    this._sideFlicking.forEach((child) => {
-      child.dragThreshold = 10;
-    });
-    this._moveDirection = null;
-
     if (visiblePanels.length > 1) {
       this._nextIndex =
         e.direction === "NEXT"
@@ -295,22 +420,11 @@ export class CrossFlicking extends Flicking {
       this._nextIndex = visiblePanels[0].index;
     }
 
-    // _syncToCategory에서 완전히 가로 이동이 이루어지기 전에 세로 방향 index가 변하는 경우가 있어 requestAnimationFrame 처리
-    requestAnimationFrame(() => {
-      this._sideFlicking.forEach((child, i) => {
-        if (this._nextIndex !== i) {
-          const { start, end } = this._sideState[i];
+    this._setDraggable(MOVE_DIRECTION.VERTICAL, true);
+    this._moveDirection = null;
 
-          if (child.index < start) {
-            child.stopAnimation();
-            void child.moveTo(start, 0);
-          } else if (child.index > end) {
-            child.stopAnimation();
-            void child.moveTo(end, 0);
-          }
-        }
-      });
-    });
+    // _syncToCategory에서 완전히 가로 이동이 이루어지기 전에 세로 방향 index가 변하는 경우가 있어 requestAnimationFrame 처리
+    requestAnimationFrame(() => this._setPreviousSideIndex());
 
     if (e.isTrusted) {
       this._syncToCategory(
@@ -321,27 +435,25 @@ export class CrossFlicking extends Flicking {
   };
 
   private _onSideHoldStart = (): void => {
-    this._sideFlicking.forEach((child) => {
-      child.dragThreshold = 10;
-    });
+    this._setDraggable(MOVE_DIRECTION.VERTICAL, true);
     this._moveDirection = null;
   };
 
   private _onSideMove = (e: MoveEvent): void => {
     if (e.isTrusted && !this._moveDirection) {
-      this.dragThreshold = Infinity;
+      this._setDraggable(MOVE_DIRECTION.HORIZONTAL, false);
       this._moveDirection = MOVE_DIRECTION.VERTICAL;
     }
   };
 
   private _onSideMoveEnd = (): void => {
-    this.dragThreshold = 10;
+    this._setDraggable(MOVE_DIRECTION.HORIZONTAL, true);
     this._moveDirection = null;
   };
 
   private _onSideChanged = (e: ChangedEvent): void => {
-    // this.visiblePanels.length 가 2보다 크다면 가로 방향 Flicking이 조작 중이라는 것을 의미합니다.
-    // 이 경우 가로 방향 Flicking의 이동이 완전히 끝난 뒤 _onHorizontalMoveEnd 에서 syncToCategory할 것이므로 여기서는 하지 않습니다.
+    // If this.visiblePanels.length >= 2, it means that horizontal flicking is being dragged.
+    // In this case, syncToCategory in _onHorizontalMoveEnd will fire after moving finishes, so we don't fire it here.
     if (
       this.visiblePanels.length < 2 &&
       this._sideFlicking[this.index] === e.currentTarget

package/src/Flicking.ts

@@ -1739,7 +1739,7 @@ class Flicking extends Component<FlickingEvents> {
     if (!defaultPanel) return;
 
     const nearestAnchor = camera.findNearestAnchor(defaultPanel.position);
-    const initialPanel = (nearestAnchor && defaultPanel.index !== nearestAnchor.panel.index) ? nearestAnchor.panel : defaultPanel;
+    const initialPanel = (nearestAnchor && defaultPanel.position !== nearestAnchor.panel.position && defaultPanel.index !== nearestAnchor.panel.index) ? nearestAnchor.panel : defaultPanel;
     control.setActive(initialPanel, null, false);
 
     if (!nearestAnchor) {

package/src/camera/Camera.ts

@@ -32,6 +32,7 @@ class Camera {
   private _mode: CameraMode;
   private _el: HTMLElement;
   private _transform: string;
+  private _lookedOffset = 0;
   private _position: number;
   private _alignPos: number;
   private _offset: number;
@@ -292,6 +293,8 @@ class Camera {
    * @return {this}
    */
   public lookAt(pos: number): void {
+    const prevOffset = this._offset;
+    const isChangedOffset = this._lookedOffset !== prevOffset;
     const flicking = getFlickingAttached(this._flicking);
     const prevPos = this._position;
 
@@ -304,7 +307,12 @@ class Camera {
     if (toggled) {
       void flicking.renderer.render().then(() => {
         this.updateOffset();
+        this._lookedOffset = this._offset;
       });
+    } else if (isChangedOffset) {
+      // sync offset for renderOnlyVisible on resize
+      this.updateOffset();
+      this._lookedOffset = this._offset;
     } else {
       this.applyTransform();
     }
@@ -502,8 +510,8 @@ class Camera {
   }
 
   /**
-   * Update Viewport's height to active panel's height
-   * @ko 현재 선택된 패널의 높이와 동일하도록 뷰포트의 높이를 업데이트합니다
+   * Update Viewport's height to visible panel's max height
+   * @ko 현재 활성화된 패널과 보이는 패널의 최대 높이와 동일하도록 뷰포트의 높이를 업데이트합니다
    * @throws {FlickingError}
    * {@link ERROR_CODE NOT_ATTACHED_TO_FLICKING} When {@link Camera#init init} is not called before
    * <ko>{@link ERROR_CODE NOT_ATTACHED_TO_FLICKING} {@link Camera#init init}이 이전에 호출되지 않은 경우</ko>
@@ -513,11 +521,22 @@ class Camera {
   public updateAdaptiveHeight() {
     const flicking = getFlickingAttached(this._flicking);
     const activePanel = flicking.control.activePanel;
+    const visiblePanels = flicking.visiblePanels;
+
+    const selectedPanels = [...visiblePanels];
+
+    if (activePanel) {
+      selectedPanels.push(activePanel);
+    }
+
+    if (!flicking.horizontal || !flicking.adaptive || !selectedPanels.length) return;
+
+
+    const maxHeight = Math.max(...selectedPanels.map(panel => panel.height));
 
-    if (!flicking.horizontal || !flicking.adaptive || !activePanel) return;
 
     flicking.viewport.setSize({
-      height: activePanel.height
+      height: maxHeight
     });
   }
 
@@ -599,6 +618,7 @@ class Camera {
 
   private _resetInternalValues() {
     this._position = 0;
+    this._lookedOffset = 0;
     this._alignPos = 0;
     this._offset = 0;
     this._circularOffset = 0;

package/src/control/states/HoldingState.ts

@@ -39,6 +39,10 @@ class HoldingState extends State {
 
     const inputEvent = axesEvent.inputEvent as { offsetX: number; offsetY: number };
 
+    if (!inputEvent) {
+      return;
+    }
+
     const offset = flicking.horizontal
       ? inputEvent.offsetX
       : inputEvent.offsetY;