@egjs/flicking 4.15.0 → 4.16.0-beta.1

package/src/control/SnapControl.ts

@@ -3,86 +3,59 @@
  * egjs projects are licensed under the MIT license
  */
 import { OnRelease } from "@egjs/axes";
-
-import FlickingError from "../core/FlickingError";
+import * as AXES from "../constants/internal";
 import AnchorPoint from "../core/AnchorPoint";
+import * as ERROR from "../error/codes";
+import FlickingError from "../error/FlickingError";
 import { circulateIndex, clamp, getFlickingAttached } from "../utils";
-import * as AXES from "../const/axes";
-import * as ERROR from "../const/error";
 
 import Control from "./Control";
 
 /**
- * An options for the {@link SnapControl}
- * @ko {@link SnapControl} 생성시 사용되는 옵션
- * @interface
- * @property {number} count Maximum number of panels can go after release<ko>입력 중단 이후 통과하여 이동할 수 있는 패널의 최대 갯수</ko>
+ * Options for the {@link SnapControl}
  */
 export interface SnapControlOptions {
+  /** Maximum number of panels can go after release */
   count: number;
 }
 
 /**
  * A {@link Control} that uses a release momentum to choose destination panel
- * @ko 입력을 중단한 시점의 가속도에 영향받아 도달할 패널을 계산하는 이동 방식을 사용하는 {@link Control}
+ * @public
  */
 class SnapControl extends Control {
   private _count: SnapControlOptions["count"];
 
   /**
    * Maximum number of panels can go after release
-   * @ko 입력 중단 이후 통과하여 이동할 수 있는 패널의 최대 갯수
-   * @type {number}
-   * @default Infinity
+   * @defaultValue Infinity
    */
-  public get count() { return this._count; }
+  public get count(): number {
+    return this._count;
+  }
 
-  public set count(val: SnapControlOptions["count"]) { this._count = val; }
+  public set count(val: SnapControlOptions["count"]) {
+    this._count = val;
+  }
 
-  /** */
-  public constructor({
-    count = Infinity
-  }: Partial<SnapControlOptions> = {}) {
+  public constructor(options: Partial<SnapControlOptions> = {}) {
     super();
 
+    const { count = Infinity } = options;
+
     this._count = count;
   }
 
   /**
    * Move {@link Camera} to the given position
-   * @ko {@link Camera}를 주어진 좌표로 이동합니다
-   * @param {number} position The target position to move<ko>이동할 좌표</ko>
-   * @param {number} duration Duration of the panel movement animation (unit: ms).<ko>패널 이동 애니메이션 진행 시간 (단위: ms)</ko>
-   * @param {object} [axesEvent] {@link https://naver.github.io/egjs-axes/release/latest/doc/eg.Axes.html#event:release release} event of {@link https://naver.github.io/egjs-axes/ Axes}
-   * <ko>{@link https://naver.github.io/egjs-axes/ Axes}의 {@link https://naver.github.io/egjs-axes/release/latest/doc/eg.Axes.html#event:release release} 이벤트</ko>
-   * @fires Flicking#moveStart
-   * @fires Flicking#move
-   * @fires Flicking#moveEnd
-   * @fires Flicking#willChange
-   * @fires Flicking#changed
-   * @fires Flicking#willRestore
-   * @fires Flicking#restored
-   * @fires Flicking#needPanel
-   * @fires Flicking#visibleChange
-   * @fires Flicking#reachEdge
-   * @throws {FlickingError}
-   * |code|condition|
-   * |---|---|
-   * |{@link ERROR_CODE POSITION_NOT_REACHABLE}|When the given panel is already removed or not in the Camera's {@link Camera#range range}|
-   * |{@link ERROR_CODE NOT_ATTACHED_TO_FLICKING}|When {@link Control#init init} is not called before|
-   * |{@link ERROR_CODE ANIMATION_INTERRUPTED}|When the animation is interrupted by user input|
-   * |{@link ERROR_CODE STOP_CALLED_BY_USER}|When the animation is interrupted by user input|
-   * <ko>
-   *
-   * |code|condition|
-   * |---|---|
-   * |{@link ERROR_CODE POSITION_NOT_REACHABLE}|주어진 패널이 제거되었거나, Camera의 {@link Camera#range range} 밖에 있을 경우|
-   * |{@link ERROR_CODE NOT_ATTACHED_TO_FLICKING}|{@link Control#init init}이 이전에 호출되지 않은 경우|
-   * |{@link ERROR_CODE ANIMATION_INTERRUPTED}|사용자 입력에 의해 애니메이션이 중단된 경우|
-   * |{@link ERROR_CODE STOP_CALLED_BY_USER}|발생된 이벤트들 중 하나라도 `stop()`이 호출된 경우|
-   *
-   * </ko>
-   * @return {Promise<void>} A Promise which will be resolved after reaching the target position<ko>해당 좌표 도달시에 resolve되는 Promise</ko>
+   * @remarks
+   * This method calculates the snap target based on the release momentum and threshold settings.
+   * @param position - The target position to move
+   * @param duration - Duration of the panel movement animation (unit: ms)
+   * @param axesEvent - {@link https://naver.github.io/egjs-axes/docs/api/Axes#event-release | release} event of {@link https://naver.github.io/egjs-axes/ | Axes}
+   * @fires {@link MovementEvents}
+   * @throws {@link MovementErrors}
+   * @returns A Promise which will be resolved after reaching the target position
    */
   public moveToPosition(position: number, duration: number, axesEvent?: OnRelease) {
     const flicking = getFlickingAttached(this._flicking);
@@ -92,18 +65,19 @@ class SnapControl extends Control {
     const state = this._controller.state;
 
     if (!activeAnchor || !anchorAtCamera) {
-      return Promise.reject(new FlickingError(ERROR.MESSAGE.POSITION_NOT_REACHABLE(position), ERROR.CODE.POSITION_NOT_REACHABLE));
+      return Promise.reject(
+        new FlickingError(ERROR.MESSAGE.POSITION_NOT_REACHABLE(position), ERROR.CODE.POSITION_NOT_REACHABLE)
+      );
     }
 
     const snapThreshold = this._calcSnapThreshold(flicking.threshold, position, activeAnchor);
 
-    const posDelta = flicking.animating
-      ? state.delta
-      : position - camera.position;
+    const posDelta = flicking.animating ? state.delta : position - camera.position;
     const absPosDelta = Math.abs(posDelta);
-    const snapDelta = axesEvent && axesEvent.delta[AXES.POSITION_KEY] !== 0
-      ? Math.abs(axesEvent.delta[AXES.POSITION_KEY])
-      : absPosDelta;
+    const snapDelta =
+      axesEvent && axesEvent.delta[AXES.POSITION_KEY] !== 0
+        ? Math.abs(axesEvent.delta[AXES.POSITION_KEY])
+        : absPosDelta;
     let targetAnchor: AnchorPoint;
 
     if (snapDelta >= snapThreshold && snapDelta > 0) {
@@ -130,6 +104,11 @@ class SnapControl extends Control {
     });
   }
 
+  /**
+   * @internal
+   * @privateRemarks
+   * Finds the anchor point to snap to based on the target position and count option.
+   */
   private _findSnappedAnchor(position: number, anchorAtCamera: AnchorPoint): AnchorPoint {
     const flicking = getFlickingAttached(this._flicking);
     const camera = flicking.camera;
@@ -144,7 +123,7 @@ class SnapControl extends Control {
       throw new FlickingError(ERROR.MESSAGE.POSITION_NOT_REACHABLE(position), ERROR.CODE.POSITION_NOT_REACHABLE);
     }
 
-    if (!isFinite(count)) {
+    if (!Number.isFinite(count)) {
       return anchorAtPosition;
     }
 
@@ -152,11 +131,15 @@ class SnapControl extends Control {
     const anchors = camera.anchorPoints;
 
     let loopCount = Math.sign(position - currentPos) * Math.floor(Math.abs(position - currentPos) / camera.rangeDiff);
-    if ((position > currentPos && anchorAtPosition.index < anchorAtCamera.index)
-      || (anchorAtPosition.position > anchorAtCamera.position && anchorAtPosition.index === anchorAtCamera.index)) {
+    if (
+      (position > currentPos && anchorAtPosition.index < anchorAtCamera.index) ||
+      (anchorAtPosition.position > anchorAtCamera.position && anchorAtPosition.index === anchorAtCamera.index)
+    ) {
       loopCount += 1;
-    } else if ((position < currentPos && anchorAtPosition.index > anchorAtCamera.index)
-      || (anchorAtPosition.position < anchorAtCamera.position && anchorAtPosition.index === anchorAtCamera.index)) {
+    } else if (
+      (position < currentPos && anchorAtPosition.index > anchorAtCamera.index) ||
+      (anchorAtPosition.position < anchorAtCamera.position && anchorAtPosition.index === anchorAtCamera.index)
+    ) {
       loopCount -= 1;
     }
 
@@ -174,7 +157,8 @@ class SnapControl extends Control {
     }
 
     if (flicking.circularEnabled) {
-      const targetAnchor = anchors[circulateIndex(anchorAtCamera.index + Math.sign(position - currentPos) * count, panelCount)];
+      const targetAnchor =
+        anchors[circulateIndex(anchorAtCamera.index + Math.sign(position - currentPos) * count, panelCount)];
       let loop = Math.floor(count / panelCount);
 
       if (position > currentPos && targetAnchor.index < anchorAtCamera.index) {
@@ -193,6 +177,11 @@ class SnapControl extends Control {
     }
   }
 
+  /**
+   * @internal
+   * @privateRemarks
+   * Finds the adjacent anchor point based on the movement direction.
+   */
   private _findAdjacentAnchor(position: number, posDelta: number, anchorAtCamera: AnchorPoint): AnchorPoint {
     const flicking = getFlickingAttached(this._flicking);
     const camera = flicking.camera;
@@ -205,11 +194,17 @@ class SnapControl extends Control {
       }
     }
 
-    const adjacentAnchor = (posDelta > 0 ? camera.getNextAnchor(anchorAtCamera) : camera.getPrevAnchor(anchorAtCamera)) ?? anchorAtCamera;
+    const adjacentAnchor =
+      (posDelta > 0 ? camera.getNextAnchor(anchorAtCamera) : camera.getPrevAnchor(anchorAtCamera)) ?? anchorAtCamera;
 
     return adjacentAnchor;
   }
 
+  /**
+   * @internal
+   * @privateRemarks
+   * Calculates the snap threshold based on the panel size and alignment.
+   */
   private _calcSnapThreshold(threshold: number, position: number, activeAnchor: AnchorPoint): number {
     const isNextDirection = position > activeAnchor.position;
     const panel = activeAnchor.panel;
@@ -222,9 +217,10 @@ class SnapControl extends Control {
      * |<------>|<------------>|
      * [        |<-Anchor      ]
      */
-    return Math.max(threshold, isNextDirection
-      ? panelSize - alignPos + panel.margin.next
-      : alignPos + panel.margin.prev);
+    return Math.max(
+      threshold,
+      isNextDirection ? panelSize - alignPos + panel.margin.next : alignPos + panel.margin.prev
+    );
   }
 }
 

package/src/control/StateMachine.ts

@@ -3,15 +3,13 @@
  * egjs projects are licensed under the MIT license
  */
 import { AxesEvents } from "@egjs/axes";
-
+import * as AXES from "../constants/internal";
 import Flicking from "../Flicking";
-import * as AXES from "../const/axes";
-
-import IdleState from "./states/IdleState";
-import HoldingState from "./states/HoldingState";
-import DraggingState from "./states/DraggingState";
 import AnimatingState from "./states/AnimatingState";
 import DisabledState from "./states/DisabledState";
+import DraggingState from "./states/DraggingState";
+import HoldingState from "./states/HoldingState";
+import IdleState from "./states/IdleState";
 import State, { STATE_TYPE } from "./states/State";
 
 /**
@@ -20,16 +18,21 @@ import State, { STATE_TYPE } from "./states/State";
 class StateMachine {
   private _state: State;
 
-  public get state(): State { return this._state; }
+  public get state(): State {
+    return this._state;
+  }
 
   public constructor() {
     this._state = new IdleState();
   }
 
-  public fire(eventType: keyof AxesEvents, externalCtx: {
-    flicking: Flicking;
-    axesEvent: any;
-  }) {
+  public fire(
+    eventType: keyof AxesEvents,
+    externalCtx: {
+      flicking: Flicking;
+      axesEvent: any;
+    }
+  ) {
     const currentState = this._state;
     const ctx = { ...externalCtx, transitTo: this.transitTo };
 

package/src/control/StrictControl.ts

@@ -5,24 +5,23 @@
 import { OnRelease } from "@egjs/axes";
 
 import Panel from "../core/panel/Panel";
-import FlickingError from "../core/FlickingError";
+import * as ERROR from "../error/codes";
+import FlickingError from "../error/FlickingError";
 import { clamp, getFlickingAttached, getMinusCompensatedIndex, isBetween } from "../utils";
-import * as ERROR from "../const/error";
 
-import Control from "./Control";
+import Control, { MoveToPanelParams } from "./Control";
 /**
- * An options for the {@link StrictControl}
- * @ko {@link StrictControl} 생성시 사용되는 옵션
- * @interface
- * @property {number} count Maximum number of panels that can be moved at a time<ko>최대로 움직일 수 있는 패널의 개수</ko>
+ * Options for the {@link StrictControl}
  */
 export interface StrictControlOptions {
+  /** Maximum number of panels that can be moved at a time */
   count: number;
 }
 
 /**
- * A {@link Control} that allow you to select the maximum number of panels to move at a time
- * @ko 한번에 최대로 이동할 패널의 개수를 선택 가능한 {@link Control}
+ * A {@link Control} that allows you to select the maximum number of panels to move at a time
+ * @since 4.2.0
+ * @public
  */
 class StrictControl extends Control {
   private _count: number;
@@ -30,28 +29,29 @@ class StrictControl extends Control {
 
   /**
    * Maximum number of panels that can be moved at a time
-   * @ko 최대로 움직일 수 있는 패널의 개수
-   * @type {number}
-   * @default 1
+   * @defaultValue 1
    */
-  public get count() { return this._count; }
+  public get count(): number {
+    return this._count;
+  }
 
-  public set count(val: StrictControlOptions["count"]) { this._count = val; }
+  public set count(val: StrictControlOptions["count"]) {
+    this._count = val;
+  }
 
-  /** */
-  public constructor({
-    count = 1
-  }: Partial<StrictControlOptions> = {}) {
+  public constructor(options: Partial<StrictControlOptions> = {}) {
     super();
 
+    const { count = 1 } = options;
+
     this._count = count;
     this._resetIndexRange();
   }
 
   /**
    * Destroy Control and return to initial state
-   * @ko Control을 초기 상태로 되돌립니다
-   * @return {void}
+   * @remarks
+   * This method also resets the index range used for movement constraints.
    */
   public destroy() {
     super.destroy();
@@ -60,10 +60,10 @@ class StrictControl extends Control {
   }
 
   /**
-   * Update {@link Control#controller controller}'s state
-   * @ko {@link Control#controller controller}의 내부 상태를 갱신합니다
-   * @chainable
-   * @return {this}
+   * Update {@link Control.controller | controller}'s state
+   * @remarks
+   * StrictControl limits the movement range based on the {@link StrictControlOptions.count | count} option.
+   * @returns The current instance for method chaining
    */
   public updateInput(): this {
     const flicking = getFlickingAttached(this._flicking);
@@ -93,7 +93,7 @@ class StrictControl extends Control {
 
     if (prevPanelIndex < 0) {
       prevPanelIndex = flicking.circularEnabled
-        ? getMinusCompensatedIndex((prevPanelIndex + 1) % panelCount - 1, panelCount)
+        ? getMinusCompensatedIndex(((prevPanelIndex + 1) % panelCount) - 1, panelCount)
         : clamp(prevPanelIndex, 0, panelCount - 1);
     }
     if (nextPanelIndex >= panelCount) {
@@ -141,7 +141,7 @@ class StrictControl extends Control {
     return this;
   }
 
-  public async moveToPanel(panel: Panel, options: Parameters<Control["moveToPanel"]>[1]): Promise<void> {
+  public async moveToPanel(panel: Panel, options: MoveToPanelParams): Promise<void> {
     const flicking = getFlickingAttached(this._flicking);
     const camera = flicking.camera;
     const controller = this._controller;
@@ -153,41 +153,16 @@ class StrictControl extends Control {
 
   /**
    * Move {@link Camera} to the given position
-   * @ko {@link Camera}를 주어진 좌표로 이동합니다
-   * @param {number} position The target position to move<ko>이동할 좌표</ko>
-   * @param {number} duration Duration of the panel movement animation (unit: ms).<ko>패널 이동 애니메이션 진행 시간 (단위: ms)</ko>
-   * @param {object} [axesEvent] {@link https://naver.github.io/egjs-axes/release/latest/doc/eg.Axes.html#event:release release} event of {@link https://naver.github.io/egjs-axes/ Axes}
-   * <ko>{@link https://naver.github.io/egjs-axes/ Axes}의 {@link https://naver.github.io/egjs-axes/release/latest/doc/eg.Axes.html#event:release release} 이벤트</ko>
-   * @fires Flicking#moveStart
-   * @fires Flicking#move
-   * @fires Flicking#moveEnd
-   * @fires Flicking#willChange
-   * @fires Flicking#changed
-   * @fires Flicking#willRestore
-   * @fires Flicking#restored
-   * @fires Flicking#needPanel
-   * @fires Flicking#visibleChange
-   * @fires Flicking#reachEdge
-   * @throws {FlickingError}
-   * |code|condition|
-   * |---|---|
-   * |{@link ERROR_CODE POSITION_NOT_REACHABLE}|When the given panel is already removed or not in the Camera's {@link Camera#range range}|
-   * |{@link ERROR_CODE NOT_ATTACHED_TO_FLICKING}|When {@link Control#init init} is not called before|
-   * |{@link ERROR_CODE ANIMATION_INTERRUPTED}|When the animation is interrupted by user input|
-   * |{@link ERROR_CODE STOP_CALLED_BY_USER}|When the animation is interrupted by user input|
-   * <ko>
-   *
-   * |code|condition|
-   * |---|---|
-   * |{@link ERROR_CODE POSITION_NOT_REACHABLE}|주어진 패널이 제거되었거나, Camera의 {@link Camera#range range} 밖에 있을 경우|
-   * |{@link ERROR_CODE NOT_ATTACHED_TO_FLICKING}|{@link Control#init init}이 이전에 호출되지 않은 경우|
-   * |{@link ERROR_CODE ANIMATION_INTERRUPTED}|사용자 입력에 의해 애니메이션이 중단된 경우|
-   * |{@link ERROR_CODE STOP_CALLED_BY_USER}|발생된 이벤트들 중 하나라도 `stop()`이 호출된 경우|
-   *
-   * </ko>
-   * @return {Promise<void>} A Promise which will be resolved after reaching the target position<ko>해당 좌표 도달시에 resolve되는 Promise</ko>
+   * @remarks
+   * StrictControl restricts movement to panels within the allowed index range based on the count option.
+   * @param position - The target position to move
+   * @param duration - Duration of the panel movement animation (unit: ms)
+   * @param axesEvent - {@link https://naver.github.io/egjs-axes/docs/api/Axes#event-release | release} event of {@link https://naver.github.io/egjs-axes/ | Axes}
+   * @fires {@link MovementEvents}
+   * @throws {@link MovementErrors}
+   * @returns A Promise which will be resolved after reaching the target position
    */
-  public moveToPosition(position: number, duration: number, axesEvent?: OnRelease) {
+  public moveToPosition(position: number, duration: number, axesEvent?: OnRelease): Promise<void> {
     const flicking = getFlickingAttached(this._flicking);
     const camera = flicking.camera;
     const currentPanel = this._nextPanel ?? this._activePanel;
@@ -200,18 +175,17 @@ class StrictControl extends Control {
     const anchorAtPosition = camera.findAnchorIncludePosition(clampedPosition);
 
     if (!anchorAtPosition || !currentPanel) {
-      return Promise.reject(new FlickingError(ERROR.MESSAGE.POSITION_NOT_REACHABLE(position), ERROR.CODE.POSITION_NOT_REACHABLE));
+      return Promise.reject(
+        new FlickingError(ERROR.MESSAGE.POSITION_NOT_REACHABLE(position), ERROR.CODE.POSITION_NOT_REACHABLE)
+      );
     }
 
     const prevPos = currentPanel.position;
-    const posDelta = flicking.animating
-      ? state.delta
-      : position - camera.position;
+    const posDelta = flicking.animating ? state.delta : position - camera.position;
 
     const isOverThreshold = Math.abs(posDelta) >= flicking.threshold;
-    const adjacentAnchor = (position > prevPos)
-      ? camera.getNextAnchor(anchorAtPosition)
-      : camera.getPrevAnchor(anchorAtPosition);
+    const adjacentAnchor =
+      position > prevPos ? camera.getNextAnchor(anchorAtPosition) : camera.getPrevAnchor(anchorAtPosition);
 
     let targetPos: number;
     let targetPanel: Panel;
@@ -221,12 +195,16 @@ class StrictControl extends Control {
     const lastAnchor = anchors[anchors.length - 1];
 
     // position이 bounce으로 인하여 범위를 넘어가야 동작하도록 변경
-    const shouldBounceToFirst = position < cameraRange.min && isBetween(firstAnchor.panel.index, indexRange.min, indexRange.max);
-    const shouldBounceToLast = position > cameraRange.max && isBetween(lastAnchor.panel.index, indexRange.min, indexRange.max);
+    const shouldBounceToFirst =
+      position < cameraRange.min && isBetween(firstAnchor.panel.index, indexRange.min, indexRange.max);
+    const shouldBounceToLast =
+      position > cameraRange.max && isBetween(lastAnchor.panel.index, indexRange.min, indexRange.max);
 
-    const isAdjacent = adjacentAnchor && (indexRange.min <= indexRange.max
-      ? isBetween(adjacentAnchor.index, indexRange.min, indexRange.max)
-      : adjacentAnchor.index >= indexRange.min || adjacentAnchor.index <= indexRange.max);
+    const isAdjacent =
+      adjacentAnchor &&
+      (indexRange.min <= indexRange.max
+        ? isBetween(adjacentAnchor.index, indexRange.min, indexRange.max)
+        : adjacentAnchor.index >= indexRange.min || adjacentAnchor.index <= indexRange.max);
 
     if (shouldBounceToFirst || shouldBounceToLast) {
       // In bounce area
@@ -246,7 +224,9 @@ class StrictControl extends Control {
       // Fallback to nearest panel from current camera
       const anchorAtCamera = camera.findNearestAnchor(camera.position);
       if (!anchorAtCamera) {
-        return Promise.reject(new FlickingError(ERROR.MESSAGE.POSITION_NOT_REACHABLE(position), ERROR.CODE.POSITION_NOT_REACHABLE));
+        return Promise.reject(
+          new FlickingError(ERROR.MESSAGE.POSITION_NOT_REACHABLE(position), ERROR.CODE.POSITION_NOT_REACHABLE)
+        );
       }
       return this.moveToPanel(anchorAtCamera.panel, {
         duration,
@@ -269,6 +249,11 @@ class StrictControl extends Control {
     this.updateInput();
   };
 
+  /**
+   * @internal
+   * @privateRemarks
+   * Resets the index range to default values.
+   */
   private _resetIndexRange() {
     this._indexRange = { min: 0, max: 0 };
   }

package/src/control/index.ts

@@ -2,18 +2,19 @@
  * Copyright (c) 2015 NAVER Corp.
  * egjs projects are licensed under the MIT license
  */
+
+import AxesController from "./AxesController";
 import Control from "./Control";
-import SnapControl, { SnapControlOptions } from "./SnapControl";
 import FreeControl, { FreeControlOptions } from "./FreeControl";
+import SnapControl, { SnapControlOptions } from "./SnapControl";
+import StateMachine from "./StateMachine";
 import StrictControl, { StrictControlOptions } from "./StrictControl";
-import AxesController from "./AxesController";
-import State from "./states/State";
-import IdleState from "./states/IdleState";
-import HoldingState from "./states/HoldingState";
-import DraggingState from "./states/DraggingState";
 import AnimatingState from "./states/AnimatingState";
 import DisabledState from "./states/DisabledState";
-import StateMachine from "./StateMachine";
+import DraggingState from "./states/DraggingState";
+import HoldingState from "./states/HoldingState";
+import IdleState from "./states/IdleState";
+import State from "./states/State";
 
 export {
   Control,
@@ -30,8 +31,4 @@ export {
   StateMachine
 };
 
-export type {
-  SnapControlOptions,
-  FreeControlOptions,
-  StrictControlOptions
-};
+export type { SnapControlOptions, FreeControlOptions, StrictControlOptions };

package/src/control/states/AnimatingState.ts

@@ -4,28 +4,23 @@
  */
 import { ComponentEvent } from "@egjs/component";
 
-import { EVENTS } from "../../const/external";
+import { EVENTS } from "../../event/names";
 import { getDirection } from "../../utils";
 
 import State, { STATE_TYPE } from "./State";
 
 /**
  * A state that activates when Flicking's animating by user input or method call
- * @ko 사용자 입력이나 메소드 호출에 의해 Flicking의 애니메이션이 동작중인 상태
  * @internal
  */
 class AnimatingState extends State {
   /**
    * Whether user is clicking or touching
-   * @ko 현재 사용자가 클릭/터치중인지 여부
-   * @type {false}
    * @readonly
    */
   public readonly holding = false;
   /**
    * Whether Flicking's animating
-   * @ko 현재 애니메이션 동작 여부
-   * @type {true}
    * @readonly
    */
   public readonly animating = true;
@@ -65,11 +60,13 @@ class AnimatingState extends State {
 
     transitTo(STATE_TYPE.IDLE);
 
-    flicking.trigger(new ComponentEvent(EVENTS.MOVE_END, {
-      isTrusted: axesEvent.isTrusted,
-      direction: getDirection(animatingContext.start, animatingContext.end),
-      axesEvent
-    }));
+    flicking.trigger(
+      new ComponentEvent(EVENTS.MOVE_END, {
+        isTrusted: axesEvent.isTrusted,
+        direction: getDirection(animatingContext.start, animatingContext.end),
+        axesEvent
+      })
+    );
 
     const targetPanel = this._targetPanel;
     if (targetPanel) {

package/src/control/states/DisabledState.ts

@@ -6,21 +6,16 @@ import State, { STATE_TYPE } from "./State";
 
 /**
  * A state that activates when Flicking is stopped by event's `stop` method
- * @ko 이벤트의 `stop`호출에 의해 Flicking이 정지된 상태
  * @internal
  */
 class DisabledState extends State {
   /**
    * Whether user is clicking or touching
-   * @ko 현재 사용자가 클릭/터치중인지 여부
-   * @type {false}
    * @readonly
    */
   public readonly holding = false;
   /**
    * Whether Flicking's animating
-   * @ko 현재 애니메이션 동작 여부
-   * @type {true}
    * @readonly
    */
   public readonly animating = true;

package/src/control/states/DraggingState.ts

@@ -3,29 +3,23 @@
  * egjs projects are licensed under the MIT license
  */
 import { ComponentEvent } from "@egjs/component";
-
-import { EVENTS } from "../../const/external";
-import * as AXES from "../../const/axes";
+import * as AXES from "../../constants/internal";
+import { EVENTS } from "../../event/names";
 
 import State, { STATE_TYPE } from "./State";
 
 /**
  * A state that activates when user's dragging the Flicking area
- * @ko 사용자가 드래깅중인 상태
  * @internal
  */
 class DraggingState extends State {
   /**
    * Whether user is clicking or touching
-   * @ko 현재 사용자가 클릭/터치중인지 여부
-   * @type {true}
    * @readonly
    */
   public readonly holding = true;
   /**
    * Whether Flicking's animating
-   * @ko 현재 애니메이션 동작 여부
-   * @type {true}
    * @readonly
    */
   public readonly animating = true;
@@ -39,9 +33,11 @@ class DraggingState extends State {
 
     // Update last position to cope with Axes's animating behavior
     // Axes uses start position when animation start
-    flicking.trigger(new ComponentEvent(EVENTS.HOLD_END, {
-      axesEvent
-    }));
+    flicking.trigger(
+      new ComponentEvent(EVENTS.HOLD_END, {
+        axesEvent
+      })
+    );
 
     if (flicking.renderer.panelCount <= 0) {
       // There're no panels
@@ -57,7 +53,7 @@ class DraggingState extends State {
 
     try {
       void control.moveToPosition(position, duration, axesEvent);
-    } catch (err) {
+    } catch (_err) {
       transitTo(STATE_TYPE.IDLE);
       axesEvent.setTo({ [AXES.POSITION_KEY]: flicking.camera.position }, 0);
     }