@egjs/flicking 4.11.3 → 4.12.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@egjs/flicking",
-	"version": "4.11.3",
+	"version": "4.12.0-beta.1",
 	"description": "Everyday 30 million people experience. It's reliable, flexible and extendable carousel.",
 	"main": "dist/flicking.cjs.js",
 	"module": "dist/flicking.esm.js",

package/src/CrossFlicking.ts

@@ -0,0 +1,252 @@
+/*
+ * 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 { LiteralUnion, ValueOf } from "./type/internal";
+import { EVENTS, MOVE_DIRECTION } from "./const/external";
+
+/**
+ * @interface
+ */
+export interface CrossFlickingEvents {
+  // FlickingEvent 들을 확장하자...
+}
+
+/**
+ * @interface
+ */
+export interface CrossFlickingOptions {
+  verticalOptions: FlickingOptions | 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 VerticalState {
+  start: number;
+  end: number;
+  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 _verticalFlicking: Flicking[];
+
+  // Options
+  private _verticalOptions: CrossFlickingOptions["verticalOptions"];
+
+  // Internal State
+  private _verticalState: VerticalState[];
+
+  private _moveDirection: LiteralUnion<ValueOf<typeof MOVE_DIRECTION>> | null;
+  private _nextIndex: number;
+
+  // Components
+  /**
+   * 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 verticalOptions() {
+    return this._verticalOptions;
+  }
+
+  // Options Setter
+  // UI / LAYOUT
+  // public set align(val: FlickingOptions["align"]) {
+  //   this._align = val;
+  // }
+
+  public constructor(
+    root: HTMLElement | string,
+    { verticalOptions = undefined }: Partial<CrossFlickingOptions> = {}
+  ) {
+    super(root);
+
+    // Internal states
+    this._verticalState = [];
+    this._moveDirection = null;
+    this._nextIndex = 0;
+
+    // Bind options
+    this._verticalOptions = verticalOptions;
+
+    // Create core components
+    // this._viewport = new Viewport(this, getElement(root));
+  }
+
+  /**
+   * 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(() => {
+      // data-index로 분류하기 전에 임시로 모든 children에 대해 vertical flicking으로 해보자.
+      // camera.children들에 대해 갯수 세기
+      let verticalPanels = ``;
+      this._verticalState = this.camera.children.reduce(
+        (state: VerticalState[], child: HTMLElement) => {
+          const start = state.length ? +state[state.length - 1].end + 1 : 0;
+          verticalPanels += child.children[0].innerHTML;
+          return [
+            ...state,
+            {
+              start,
+              end: start + child.children[0].children.length - 1,
+              element: child,
+            },
+          ];
+        },
+        []
+      );
+      this.camera.children.forEach((child) => {
+        child.children[0].innerHTML = verticalPanels;
+      });
+      this._verticalFlicking = this.camera.children.map((child, i) => {
+        return new Flicking(child, {
+          ...this.verticalOptions,
+          horizontal: false,
+          panelsPerView: 1,
+          defaultIndex: this._verticalState[i].start,
+        });
+      });
+
+      this.on(EVENTS.HOLD_START, this._onHorizontalHoldStart);
+      this.on(EVENTS.MOVE, this._onHorizontalMove);
+      this.on(EVENTS.MOVE_END, this._onHorizontalMoveEnd);
+
+      this._verticalFlicking.forEach((child) => {
+        child.on(EVENTS.HOLD_START, this._onVerticalHoldStart);
+        child.on(EVENTS.MOVE, this._onVerticalMove);
+        child.on(EVENTS.MOVE_END, this._onVerticalMoveEnd);
+        child.on(EVENTS.CHANGED, this._onVerticalChanged);
+      });
+    });
+  }
+
+  private _syncToCategory(index: number, outerIndex: number): void {
+    this.stopAnimation();
+    this._verticalFlicking.forEach((child, i) => {
+      const { start, end } = this._verticalState[i];
+
+      if (start <= index && end >= index && outerIndex !== i) {
+        child.stopAnimation();
+        void child.moveTo(index, 0);
+        void this.moveTo(i, 0);
+      }
+    });
+  }
+
+  private _onHorizontalHoldStart = (): void => {
+    this.dragThreshold = 10;
+    this._moveDirection = null;
+  };
+
+  private _onHorizontalMove = (e: MoveEvent): void => {
+    if (e.isTrusted && !this._moveDirection) {
+      this._verticalFlicking.forEach((child) => {
+        child.dragThreshold = Infinity;
+      });
+      this._moveDirection = MOVE_DIRECTION.HORIZONTAL;
+    }
+  };
+
+  private _onHorizontalMoveEnd = (e: MoveEndEvent): void => {
+    const visiblePanels = this.visiblePanels;
+
+    this._verticalFlicking.forEach((child) => {
+      child.dragThreshold = 10;
+    });
+    this._moveDirection = null;
+
+    if (visiblePanels.length > 1) {
+      this._nextIndex =
+        e.direction === "NEXT"
+          ? visiblePanels[1].index
+          : visiblePanels[0].index;
+    } else {
+      this._nextIndex = visiblePanels[0].index;
+    }
+
+    this._verticalFlicking.forEach((child, i) => {
+      if (this._nextIndex !== i) {
+        const { start, end } = this._verticalState[i];
+
+        if (child.index < start) {
+          child.stopAnimation();
+          void child.moveTo(start, 0);
+        } else if (child.index > end) {
+          child.stopAnimation();
+          void child.moveTo(end, 0);
+        }
+      }
+    });
+
+    if (e.isTrusted) {
+      this._syncToCategory(
+        this._verticalFlicking[this._nextIndex].index,
+        this._nextIndex
+      );
+    }
+  };
+
+  private _onVerticalHoldStart = (): void => {
+    this._verticalFlicking.forEach((child) => {
+      child.dragThreshold = 10;
+    });
+    this._moveDirection = null;
+  };
+
+  private _onVerticalMove = (e: MoveEvent): void => {
+    if (e.isTrusted && !this._moveDirection) {
+      this.dragThreshold = Infinity;
+      this._moveDirection = MOVE_DIRECTION.VERTICAL;
+    }
+  };
+
+  private _onVerticalMoveEnd = (): void => {
+    this.dragThreshold = 10;
+    this._moveDirection = null;
+  };
+
+  private _onVerticalChanged = (e: ChangedEvent): void => {
+    // this.visiblePanels.length 가 2보다 크다면 가로 방향 Flicking이 조작 중이라는 것을 의미합니다.
+    // 이 경우 가로 방향 Flicking의 이동이 완전히 끝난 뒤 _onHorizontalMoveEnd 에서 syncToCategory할 것이므로 여기서는 하지 않습니다.
+    if (
+      this.visiblePanels.length < 2 &&
+      this._verticalFlicking[this.index] === e.currentTarget
+    ) {
+      this._syncToCategory(e.index, this.index);
+    }
+  };
+}

package/src/Flicking.ts

@@ -73,6 +73,7 @@ export interface FlickingOptions {
   inputType: string[];
   moveType: ValueOf<typeof MOVE_TYPE> | MoveTypeOptions<ValueOf<typeof MOVE_TYPE>>;
   threshold: number;
+  dragThreshold: number;
   interruptable: boolean;
   bounce: number | string | [number | string, number | string];
   iOSEdgeSwipeThreshold: number;
@@ -152,6 +153,7 @@ class Flicking extends Component<FlickingEvents> {
   private _inputType: FlickingOptions["inputType"];
   private _moveType: FlickingOptions["moveType"];
   private _threshold: FlickingOptions["threshold"];
+  private _dragThreshold: FlickingOptions["dragThreshold"];
   private _interruptable: FlickingOptions["interruptable"];
   private _bounce: FlickingOptions["bounce"];
   private _iOSEdgeSwipeThreshold: FlickingOptions["iOSEdgeSwipeThreshold"];
@@ -350,7 +352,7 @@ class Flicking extends Component<FlickingEvents> {
   public get align() { return this._align; }
   /**
    * Index of the panel to move when Flicking's {@link Flicking#init init()} is called. A zero-based integer
-   * @ko Flicking의 {@link Flicking#init init()}이 호출될 때 이동할 디폴트 패널의 인덱스로, 0부터 시작하는 정수입니다
+   * @ko Flicking의 {@link Flicking#init init()}이 호출될 때 이동할 디폴트 패널의 인덱스로, 0부터 시작하는 정수입니다.
    * @type {number}
    * @default 0
    * @see {@link https://naver.github.io/egjs-flicking/Options#defaultindex defaultIndex ( Options )}
@@ -528,12 +530,20 @@ class Flicking extends Component<FlickingEvents> {
   public get moveType() { return this._moveType; }
   /**
    * Movement threshold to change panel (unit: px). It should be dragged above the threshold to change the current panel.
-   * @ko 패널 변경을 위한 이동 임계값 (단위: px). 주어진 값 이상으로 스크롤해야만 패널 변경이 가능하다.
+   * @ko 패널 변경을 위한 이동 임계값 (단위: px). 주어진 값 이상으로 스크롤해야만 패널 변경이 가능합니다.
    * @type {number}
    * @default 40
    * @see {@link https://naver.github.io/egjs-flicking/Options#threshold Threshold ( Options )}
    */
   public get threshold() { return this._threshold; }
+  /**
+   * Minimal distance of user input before recognizing (unit: px). It should be dragged above the dragThreshold to move the panel.
+   * @ko 사용자의 입력을 인식하기 위한 최소한의 거리 (단위: px). 주어진 값 이상으로 스크롤해야만 패널이 움직입니다.
+   * @type {number}
+   * @default 1
+   * @see {@link https://naver.github.io/egjs-flicking/Options#dragThreshold dragThreshold ( Options )}
+   */
+  public get dragThreshold() { return this._dragThreshold; }
   /**
    * Set animation to be interruptable by click/touch.
    * @ko 사용자의 클릭/터치로 인해 애니메이션을 도중에 멈출 수 있도록 설정합니다.
@@ -845,6 +855,16 @@ class Flicking extends Component<FlickingEvents> {
   }
 
   public set threshold(val: FlickingOptions["threshold"]) { this._threshold = val; }
+
+  public set dragThreshold(val: FlickingOptions["dragThreshold"]) {
+    this._dragThreshold = val;
+    const panInput = this._control.controller.panInput;
+
+    if (panInput) {
+      panInput.options.threshold = val;
+    }
+  }
+
   public set interruptable(val: FlickingOptions["interruptable"]) {
     this._interruptable = val;
 
@@ -969,6 +989,7 @@ class Flicking extends Component<FlickingEvents> {
     inputType = ["mouse", "touch"],
     moveType = "snap",
     threshold = 40,
+    dragThreshold = 1,
     interruptable = true,
     bounce = "20%",
     iOSEdgeSwipeThreshold = 30,
@@ -1014,6 +1035,7 @@ class Flicking extends Component<FlickingEvents> {
     this._inputType = inputType;
     this._moveType = moveType;
     this._threshold = threshold;
+    this._dragThreshold = dragThreshold;
     this._interruptable = interruptable;
     this._bounce = bounce;
     this._iOSEdgeSwipeThreshold = iOSEdgeSwipeThreshold;

package/src/const/external.ts

@@ -122,3 +122,15 @@ export const ORDER = {
   LTR: "ltr",
   RTL: "rtl"
 } as const;
+
+/**
+ * An object that contains the direction that {@link Flicking} is moving
+ * @ko {@link Flicking}이 움직이는 방향을 담고 있는 객체
+ * @type {object}
+ * @property {"horizontal"} HORIZONTAL horizontal<ko>수평 방향</ko>
+ * @property {"vertical"} VERTICAL vertical<ko>수직 방향</ko>
+ */
+export const MOVE_DIRECTION = {
+  HORIZONTAL: "horizontal",
+  VERTICAL: "vertical"
+} as const;

package/src/control/AxesController.ts

@@ -148,7 +148,7 @@ class AxesController {
     });
     this._panInput = new PanInput(flicking.viewport.element, {
       inputType: flicking.inputType,
-      threshold: 1,
+      threshold: flicking.dragThreshold,
       iOSEdgeSwipeThreshold: flicking.iOSEdgeSwipeThreshold,
       preventDefaultOnDrag: flicking.preventDefaultOnDrag,
       scale: flicking.horizontal ? [flicking.camera.panelOrder === ORDER.RTL ? 1 : -1, 0] : [0, -1],

package/src/index.ts

@@ -5,6 +5,8 @@
 import Flicking from "./Flicking";
 import type { FlickingOptions, FlickingEvents } from "./Flicking";
 
+export * from "./CrossFlicking";
+
 export * from "./core";
 export * from "./camera";
 export * from "./control";

package/src/index.umd.ts

@@ -3,6 +3,7 @@
  * egjs projects are licensed under the MIT license
  */
 import Flicking from "./Flicking";
+import * as CrossFlicking from "./CrossFlicking";
 import * as Core from "./core";
 import * as Camera from "./camera";
 import * as Control from "./control";
@@ -19,5 +20,6 @@ merge(Flicking, Renderer);
 merge(Flicking, Constants);
 merge(Flicking, CFC);
 merge(Flicking, Utils);
+merge(Flicking, CrossFlicking);
 
 export default Flicking;