@egjs/flicking 4.12.0-beta.0 → 4.12.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@egjs/flicking",
-	"version": "4.12.0-beta.0",
+	"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/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/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;