@egjs/flicking 4.12.0-beta.2 → 4.12.0-beta.3

package/package.json

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

@@ -7,7 +7,7 @@ import Flicking, { FlickingOptions } from "./Flicking";
 import { ChangedEvent, MoveEndEvent, MoveEvent } from "./type/event";
 import { LiteralUnion, ValueOf } from "./type/internal";
 import { CLASS, EVENTS, MOVE_DIRECTION } from "./const/external";
-import { getElement, toArray } from "./utils";
+import { getDataAttributes, getElement, includes, toArray } from "./utils";
 
 /**
  * @interface
@@ -40,6 +40,7 @@ export interface CrossFlickingOptions {
  * @property {string | undefined} [panels.html] An `outerHTML` of the panel element<ko>패널 엘리먼트의 `outerHTML`</ko>
  */
 export interface VerticalState {
+  key: string;
   start: number;
   end: number;
   element: HTMLElement;
@@ -74,7 +75,10 @@ export class CrossFlicking extends Flicking {
    * @see SnapControl
    * @see FreeControl
    */
-  public get verticalFlicking() { return this._verticalFlicking; }
+  public get verticalFlicking() {
+    return this._verticalFlicking;
+  }
+
   // Internal States
   /**
    * Whether Flicking's {@link Flicking#init init()} is called.
@@ -85,7 +89,10 @@ export class CrossFlicking extends Flicking {
    * @default false
    * @readonly
    */
-  public get verticalState() { return this._verticalState; }
+  public get verticalState() {
+    return this._verticalState;
+  }
+
   // Options Getter
   /**
    * Change active panel index on mouse/touch hold while animating.
@@ -111,10 +118,8 @@ export class CrossFlicking extends Flicking {
   ) {
     super(root);
 
-    const horizontalPanels = toArray(getElement(root).children[0].children) as HTMLElement[];
-
     // Internal states
-    this._verticalState = this._createVerticalState(horizontalPanels);
+    this._verticalState = this._createVerticalState();
     this._moveDirection = null;
     this._nextIndex = 0;
 
@@ -122,7 +127,7 @@ export class CrossFlicking extends Flicking {
     this._verticalOptions = verticalOptions;
 
     // Create core components
-    this._verticalFlicking = this._createVerticalFlicking(horizontalPanels);
+    this._verticalFlicking = this._createVerticalFlicking();
   }
 
   /**
@@ -150,50 +155,105 @@ export class CrossFlicking extends Flicking {
     });
   }
 
-  private _createVerticalState(panels: HTMLElement[]): VerticalState[] {
+  private _createVerticalState(): VerticalState[] {
     // data-index로 분류하기 전에 임시로 모든 children에 대해 vertical flicking으로 해보자.
     // panels에 data-attributes가 붙어있을 때와 안 붙어있을 때를 다르게 처리
     // 붙어있다면 가상의 viewport들을 index 갯수만큼 만들어줘야 한다
-    let verticalPanels = "";
-
-    const verticalState = panels.reduce(
-      (state: VerticalState[], panel: HTMLElement) => {
-        const start = state.length ? +state[state.length - 1].end + 1 : 0;
-        verticalPanels += panel.innerHTML;
-        return [
-          ...state,
-          {
-            start,
-            end: start + panel.children.length - 1,
-            element: panel
-          }
-        ];
-      },
-      []
-    );
-
+    const cameraEl = this.camera.element;
+    const panels = toArray(cameraEl.children) as HTMLElement[];
+    let verticalState: VerticalState[];
+    let verticalPanels: string = "";
+
+    // check data attribute exists
+    const groupKeys: string[] = [];
+    const groupPanels: Record<string, HTMLElement[]> = {};
     const verticalCamera = document.createElement("div");
     verticalCamera.classList.add(CLASS.CAMERA);
-    verticalCamera.innerHTML = verticalPanels;
+
     panels.forEach((panel) => {
-      [CLASS.VIEWPORT, CLASS.VERTICAL].forEach((className) => {
-        if (!panel.classList.contains(className)) {
-          panel.classList.add(className);
-        }
-      });
-      panel.innerHTML = verticalCamera.outerHTML;
+      const groupKey = getDataAttributes(panel, "data-flicking-").groupkey;
+      if (groupKey && !includes(groupKeys, groupKey)) {
+        groupKeys.push(groupKey);
+        groupPanels[groupKey] = [panel];
+      } else if (groupKey) {
+        groupPanels[groupKey].push(panel);
+      }
+      return groupKey;
     });
 
+    if (groupKeys.length) {
+      panels.forEach(() => this.remove(0));
+      verticalState = groupKeys.reduce(
+        (state: VerticalState[], key: string) => {
+          const start = state.length ? +state[state.length - 1].end + 1 : 0;
+          const element = groupPanels[key].reduce(
+            (el: HTMLElement, panel: HTMLElement) => {
+              verticalPanels += panel.outerHTML;
+              el.appendChild(panel);
+              return el;
+            },
+            document.createElement("div")
+          );
+          return [
+            ...state,
+            {
+              key,
+              start,
+              end: start + groupPanels[key].length - 1,
+              element: element,
+            },
+          ];
+        },
+        []
+      );
+
+      verticalCamera.innerHTML = verticalPanels;
+      cameraEl.innerHTML = "";
+      groupKeys.forEach(() => {
+        const panel = document.createElement("div");
+        panel.classList.add(CLASS.VIEWPORT, CLASS.VERTICAL);
+        panel.innerHTML = verticalCamera.outerHTML;
+        this.append(panel);
+      });
+    } else {
+      verticalState = panels.reduce(
+        (state: VerticalState[], panel: HTMLElement, i: number) => {
+          const start = state.length ? +state[state.length - 1].end + 1 : 0;
+          verticalPanels += panel.innerHTML;
+          return [
+            ...state,
+            {
+              key: i.toString(),
+              start,
+              end: start + panel.children.length - 1,
+              element: panel,
+            },
+          ];
+        },
+        []
+      );
+
+      verticalCamera.innerHTML = verticalPanels;
+      panels.forEach((panel) => {
+        [CLASS.VIEWPORT, CLASS.VERTICAL].forEach((className) => {
+          if (!panel.classList.contains(className)) {
+            panel.classList.add(className);
+          }
+        });
+        panel.innerHTML = verticalCamera.outerHTML;
+      });
+    }
+
     return verticalState;
   }
 
-  private _createVerticalFlicking(panels: HTMLElement[]): Flicking[] {
-    return panels.map((panel, i) => {
+  private _createVerticalFlicking(): Flicking[] {
+    return this.camera.children.map((panel, i) => {
       return new Flicking(panel, {
         ...this.verticalOptions,
         horizontal: false,
         panelsPerView: 1,
-        defaultIndex: this._verticalState[i].start
+        defaultIndex: this._verticalState[i].start,
       });
     });
   }

package/src/utils.ts

@@ -349,3 +349,24 @@ export const setPrototypeOf = Object.setPrototypeOf || ((obj, proto) => {
   obj.__proto__ = proto;
   return obj;
 });
+
+export const camelize = (str: string): string => {
+  return str.replace(/[\s-_]([a-z])/g, (all, letter) => letter.toUpperCase());
+};
+
+export const getDataAttributes = (element: HTMLElement, attributePrefix: string): Record<string, string> => {
+  const dataAttributes: Record<string, string> = {};
+  const attributes = element.attributes;
+  const length = attributes.length;
+
+  for (let i = 0; i < length; ++i) {
+    const attribute = attributes[i];
+    const { name, value } = attribute;
+    if (name.indexOf(attributePrefix) === -1) {
+      continue;
+    }
+    dataAttributes[camelize(name.replace(attributePrefix, ""))] = value;
+  }
+
+  return dataAttributes;
+};