@egjs/flicking 4.12.0-beta.7 → 4.12.0-beta.9

package/src/CrossFlicking.ts

@@ -2,43 +2,52 @@
  * 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,
+  WillChangeEvent
+} from "./type/event";
 import { LiteralUnion, ValueOf } from "./type/internal";
 import { CLASS, EVENTS, MOVE_DIRECTION } from "./const/external";
 import { getDataAttributes, includes, toArray } from "./utils";
 
-/**
- * @interface
- */
-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"
+} 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>;
 }
 
-/**
- * @interface
- */
 export interface CrossFlickingOptions extends FlickingOptions {
   sideOptions: Partial<FlickingOptions> | undefined;
-  // 한쪽 움직이면 다른 한쪽 움직임을 막을지 여부
-  // 이전 패널 기억 여부
+  preserveIndex: boolean | undefined;
+  disableSlideOnHold: boolean | undefined;
+  disableIndexSync: boolean | undefined;
 }
 
-/**
- * Flicking Status returned by {@link Flicking#getStatus}
- * @ko {@link Flicking#getStatus}에 의해 반환된 Flicking 상태 객체
- * @interface
- * @property {number} index An index of the active panel<ko>활성화된 패널의 인덱스</ko>
- * @property {object} position A info to restore camera {@link Camera#position position}<ko>카메라 {@link Camera#position position}을 설정하기 위한 정보들</ko>
- * @property {number} [position.panel] An index of the panel camera is located at<ko>카메라가 위치한 패널의 인덱스</ko>
- * @property {number} [position.progressInPanel] A progress of the camera position inside the panel<ko>패널 내에서의 카메라 위치의 진행도</ko>
- * @property {number} visibleOffset An offset to visible panel's original index. This value is available only when `visiblePanelsOnly` is `true`
- * <ko>현재 보이는 패널들을 저장했을 때, 원래의 인덱스 대비 offset. `visiblePanelsOnly` 옵션을 사용했을 때만 사용 가능합니다</ko>
- * @property {object[]} panels A data array of panels<ko>패널의 정보를 담은 배열</ko>
- * @property {index} [panels.index] An index of the panel<ko>패널의 인덱스</ko>
- * @property {string | undefined} [panels.html] An `outerHTML` of the panel element<ko>패널 엘리먼트의 `outerHTML`</ko>
- */
 export interface SideState {
   key: string;
   start: number;
@@ -46,18 +55,15 @@ export interface SideState {
   element: HTMLElement;
 }
 
-/**
- * @extends Component
- * @support {"ie": "9+(with polyfill)", "ch" : "latest", "ff" : "latest",  "sf" : "latest", "edge" : "latest", "ios" : "7+", "an" : "4.X+"}
- * @requires {@link https://github.com/naver/egjs-component|@egjs/component}
- * @requires {@link https://github.com/naver/egjs-axes|@egjs/axes}
- */
 export class CrossFlicking extends Flicking {
   // Core components
   private _sideFlicking: Flicking[];
 
   // Options
   private _sideOptions: CrossFlickingOptions["sideOptions"];
+  private _preserveIndex: CrossFlickingOptions["preserveIndex"];
+  private _disableSlideOnHold: CrossFlickingOptions["disableSlideOnHold"];
+  private _disableIndexSync: CrossFlickingOptions["disableIndexSync"];
 
   // Internal State
   private _sideState: SideState[];
@@ -65,90 +71,75 @@ export class CrossFlicking extends Flicking {
   private _nextIndex: number;
 
   // Components
-  /**
-   * {@link Control} instance of the Flicking
-   * @ko 현재 Flicking에 활성화된 {@link Control} 인스턴스
-   * @type {Control}
-   * @default SnapControl
-   * @readonly
-   * @see Control
-   * @see SnapControl
-   * @see FreeControl
-   */
   public get sideFlicking() {
     return this._sideFlicking;
   }
 
-  // Internal States
-  /**
-   * Whether Flicking's {@link Flicking#init init()} is called.
-   * This is `true` when {@link Flicking#init init()} is called, and is `false` after calling {@link Flicking#destroy destroy()}.
-   * @ko Flicking의 {@link Flicking#init init()}이 호출되었는지를 나타내는 멤버 변수.
-   * 이 값은 {@link Flicking#init init()}이 호출되었으면 `true`로 변하고, {@link Flicking#destroy destroy()}호출 이후에 다시 `false`로 변경됩니다.
-   * @type {boolean}
-   * @default false
-   * @readonly
-   */
   public get sideState() {
     return this._sideState;
   }
 
   // Options Getter
-  /**
-   * Change active panel index on mouse/touch hold while animating.
-   * `index` of the `willChange`/`willRestore` event will be used as new index.
-   * @ko 애니메이션 도중 마우스/터치 입력시 현재 활성화된 패널의 인덱스를 변경합니다.
-   * `willChange`/`willRestore` 이벤트의 `index`값이 새로운 인덱스로 사용될 것입니다.
-   * @type {FlickingOptions}
-   * @default undefined
-   * @see {@link https://naver.github.io/egjs-flicking/Options#changeonhold changeOnHold ( Options )}
-   */
-  public get sideOptions() {
-    return this._sideOptions;
-  }
+  public get sideOptions() { return this._sideOptions; }
+
+  public get preserveIndex() { return this._preserveIndex; }
+
+  public get disableSlideOnHold() { return this._disableSlideOnHold; }
+
+  public get disableIndexSync() { return this._disableIndexSync; }
 
   // Options Setter
-  // public set align(val: FlickingOptions["align"]) {
-  //   this._align = val;
-  // }
+  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> = {}
+    options: Partial<CrossFlickingOptions>
   ) {
     super(root, options);
+    const {
+      sideOptions = {},
+      preserveIndex = true,
+      disableSlideOnHold = true,
+      disableIndexSync = false
+    } = options;
 
     // Internal states
-    this._sideState = this._createSideState();
     this._moveDirection = null;
     this._nextIndex = 0;
 
     // Bind options
-    this._sideOptions = options.sideOptions;
-
-    // Create core components
-    this._sideFlicking = this._createSideFlicking();
+    this._sideOptions = sideOptions;
+    this._preserveIndex = preserveIndex;
+    this._disableSlideOnHold = disableSlideOnHold;
+    this._disableIndexSync = disableIndexSync;
   }
 
-  /**
-   * Initialize Flicking and move to the default index
-   * This is automatically called on Flicking's constructor when `autoInit` is true(default)
-   * @ko Flicking을 초기화하고, 디폴트 인덱스로 이동합니다
-   * 이 메소드는 `autoInit` 옵션이 true(default)일 경우 Flicking이 생성될 때 자동으로 호출됩니다
-   * @fires Flicking#ready
-   * @return {Promise<void>}
-   */
   public init(): Promise<void> {
-    return super.init().then(() => this._addComponentEvents());
+    return super.init().then(() => {
+      this._sideState = this._createSideState();
+      this._sideFlicking = this._createSideFlicking();
+      this._addComponentEvents();
+    });
   }
 
-  /**
-   * Destroy Flicking and remove all event handlers
-   * @ko Flicking과 하위 컴포넌트들을 초기 상태로 되돌리고, 부착된 모든 이벤트 핸들러를 제거합니다
-   * @return {void}
-   */
   public destroy(): void {
-    // TODO 모든 child flicking destroy
+    this._sideFlicking.forEach((flicking) => {
+      flicking.destroy();
+    });
     super.destroy();
   }
 
@@ -157,140 +148,151 @@ export class CrossFlicking extends Flicking {
     this.on(EVENTS.MOVE, this._onHorizontalMove);
     this.on(EVENTS.MOVE_END, this._onHorizontalMoveEnd);
 
-    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);
+
+      Object.keys(SIDE_EVENTS).forEach((name: EventKey<FlickingEvents>) => {
+        flicking.on(EVENTS[name], (event) => {
+          this.trigger(
+            new ComponentEvent(SIDE_EVENTS[name], {
+              mainIndex,
+              ...event
+            })
+          );
+        });
+      });
     });
   }
 
   private _createSideState(): SideState[] {
-    // data-index로 분류하기 전에 임시로 모든 children에 대해 side flicking으로 해보자.
-    // panels에 data-attributes가 붙어있을 때와 안 붙어있을 때를 다르게 처리
-    // 붙어있다면 가상의 viewport들을 index 갯수만큼 만들어줘야 한다
     const viewportEl = this.element;
     const cameraEl = this.camera.element;
     const panels = toArray(cameraEl.children) as HTMLElement[];
+    const isCrossStructure = getDataAttributes(
+      viewportEl,
+      "data-cross-"
+    ).structure;
     let sideState: SideState[] = [];
-    let sidePanels: string = "";
 
-    // check data attribute exists
-    const groupKeys: string[] = [];
-    const groupPanels: Record<string, HTMLElement[]> = {};
+    if (!isCrossStructure) {
+      const groupPanels = this._getGroupFromAttribute(panels);
+      const groupKeys = Object.keys(groupPanels);
+
+      if (groupKeys.length) {
+        sideState = this._getSideStateFromGroup(groupPanels);
+        this.remove(0, this.panelCount - groupKeys.length);
+      } else {
+        sideState = this._getSideStateFromPanels(panels);
+      }
+
+      this._createCrossStructure(sideState);
+    } else {
+      sideState = this._getSideStateFromCrossStructure(panels);
+    }
+
+    void this.resize();
+
+    return 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)
+      );
+    });
 
-    const isCrossStructure = getDataAttributes(viewportEl, "data-cross-").structure;
+    sideCamera.innerHTML = sidePanels;
 
-    if (!isCrossStructure) {
-      viewportEl.setAttribute("data-cross-structure", "true");
-
-      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);
+    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;
+    });
 
-      if (groupKeys.length) {
-        sideState = groupKeys.reduce(
-          (state: SideState[], key: string) => {
-            const start = state.length ? +state[state.length - 1].end + 1 : 0;
-            const element = groupPanels[key].reduce(
-              (el: HTMLElement, panel: HTMLElement) => {
-                sidePanels += panel.outerHTML;
-                el.innerHTML += panel.outerHTML;
-                return el;
-              },
-              document.createElement("div")
-            );
-            return [
-              ...state,
-              {
-                key,
-                start,
-                end: start + groupPanels[key].length - 1,
-                element: element
-              }
-            ];
-          },
-          []
-        );
+    this.element.setAttribute("data-cross-structure", "true");
+  }
 
-        this.remove(0, this.panelCount - groupKeys.length);
-        sideState.forEach((_, i) => {
-          const panel = this.camera.children[i];
-          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
-              }
-            ];
-          },
-          []
-        );
+  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);
       }
+    });
 
-      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);
+    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;
+        const element = groupPanels[key].reduce(
+          (el: HTMLElement, panel: HTMLElement) => {
+            el.innerHTML += panel.outerHTML;
+            return el;
+          },
+          document.createElement("div")
+        );
+        return [
+          ...state,
+          {
+            key,
+            start,
+            end: start + groupPanels[key].length - 1,
+            element: element
           }
-        });
-        panel.innerHTML = sideCamera.outerHTML;
-      });
-    } else {
-      (toArray(panels[0].children[0].children) as HTMLElement[]).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);
-        }
-      });
+        ];
+      },
+      []
+    );
+  }
 
-      sideState = groupKeys.reduce(
-        (state: SideState[], key: string) => {
-          const start = state.length ? +state[state.length - 1].end + 1 : 0;
-          const element = groupPanels[key].reduce(
-            (el: HTMLElement, panel: HTMLElement) => {
-              el.innerHTML += panel.outerHTML;
-              return el;
-            },
-            document.createElement("div")
-          );
-          return [
-            ...state,
-            {
-              key,
-              start,
-              end: start + groupPanels[key].length - 1,
-              element: element
-            }
-          ];
-        },
-        []
-      );
-    }
+  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
+          }
+        ];
+      },
+      []
+    );
+  }
 
-    return sideState;
+  private _getSideStateFromCrossStructure(panels: HTMLElement[]): SideState[] {
+    const groupPanels = this._getGroupFromAttribute(panels);
+    return this._getSideStateFromGroup(groupPanels);
   }
 
   private _createSideFlicking(): Flicking[] {
@@ -304,7 +306,11 @@ export class CrossFlicking extends Flicking {
     });
   }
 
-  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];
@@ -315,18 +321,61 @@ 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 threshold = draggable
+      ? this.dragThreshold && this.dragThreshold >= 10
+        ? this.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 _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;
     }
   };
@@ -334,11 +383,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"
@@ -348,20 +392,11 @@ export class CrossFlicking extends Flicking {
       this._nextIndex = visiblePanels[0].index;
     }
 
-    // _syncToCategory에서 완전히 가로 이동이 이루어지기 전에 세로 방향 index가 변하는 경우가 있어 timeout으로 처리
-    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(
@@ -372,27 +407,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