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

package/declaration/CrossFlicking.d.ts

@@ -0,0 +1,77 @@
+import Flicking, { FlickingEvents, FlickingOptions } from "./Flicking";
+import { ChangedEvent, HoldEndEvent, HoldStartEvent, MoveEndEvent, MoveEvent, MoveStartEvent, WillChangeEvent } from "./type/event";
+export declare const SIDE_EVENTS: {
+    readonly HOLD_START: "sideHoldStart";
+    readonly HOLD_END: "sideHoldEnd";
+    readonly MOVE_START: "sideMoveStart";
+    readonly MOVE: "sideMove";
+    readonly MOVE_END: "sideMoveEnd";
+    readonly WILL_CHANGE: "sideWillChange";
+    readonly CHANGED: "sideChanged";
+};
+export declare 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>;
+}
+export interface CrossFlickingOptions extends FlickingOptions {
+    sideOptions: Partial<FlickingOptions> | undefined;
+    preserveIndex: boolean | undefined;
+    disableSlideOnHold: boolean | undefined;
+    disableIndexSync: boolean | undefined;
+}
+export interface SideState {
+    key: string;
+    start: number;
+    end: number;
+    element: HTMLElement;
+}
+export declare class CrossFlicking extends Flicking {
+    private _sideFlicking;
+    private _sideOptions;
+    private _preserveIndex;
+    private _disableSlideOnHold;
+    private _disableIndexSync;
+    private _sideState;
+    private _moveDirection;
+    private _originalDragThreshold;
+    private _nextIndex;
+    get sideFlicking(): Flicking[];
+    get sideState(): SideState[];
+    get sideOptions(): CrossFlickingOptions["sideOptions"];
+    get preserveIndex(): CrossFlickingOptions["preserveIndex"];
+    get disableSlideOnHold(): CrossFlickingOptions["disableSlideOnHold"];
+    get disableIndexSync(): CrossFlickingOptions["disableIndexSync"];
+    set sideOptions(val: CrossFlickingOptions["sideOptions"]);
+    set preserveIndex(val: CrossFlickingOptions["preserveIndex"]);
+    set disableSlideOnHold(val: CrossFlickingOptions["disableSlideOnHold"]);
+    set disableIndexSync(val: CrossFlickingOptions["disableIndexSync"]);
+    constructor(root: HTMLElement | string, options: Partial<CrossFlickingOptions>);
+    init(): Promise<void>;
+    destroy(): void;
+    private _addComponentEvents;
+    private _createSideState;
+    private _createCrossStructure;
+    private _getGroupFromAttribute;
+    private _getSideStateFromGroup;
+    private _getSideStateFromPanels;
+    private _getSideStateFromCrossStructure;
+    private _createSideFlicking;
+    private _syncToCategory;
+    private _setDraggable;
+    private _setPreviousSideIndex;
+    private _onHorizontalHoldStart;
+    private _onHorizontalMove;
+    private _onHorizontalMoveEnd;
+    private _onSideHoldStart;
+    private _onSideMove;
+    private _onSideMoveEnd;
+    private _onSideChanged;
+}

package/declaration/camera/Camera.d.ts

@@ -12,6 +12,7 @@ declare class Camera {
     private _mode;
     private _el;
     private _transform;
+    private _lookedOffset;
     private _position;
     private _alignPos;
     private _offset;

package/declaration/const/external.d.ts

@@ -34,6 +34,8 @@ export declare const MOVE_TYPE: {
     readonly STRICT: "strict";
 };
 export declare const CLASS: {
+    VIEWPORT: string;
+    CAMERA: string;
     VERTICAL: string;
     HIDDEN: string;
     DEFAULT_VIRTUAL: string;
@@ -46,3 +48,7 @@ export declare const ORDER: {
     readonly LTR: "ltr";
     readonly RTL: "rtl";
 };
+export declare const MOVE_DIRECTION: {
+    readonly HORIZONTAL: "horizontal";
+    readonly VERTICAL: "vertical";
+};

package/declaration/index.d.ts

@@ -1,5 +1,7 @@
 import Flicking from "./Flicking";
 import type { FlickingOptions, FlickingEvents } from "./Flicking";
+import type { CrossFlickingOptions } from "./CrossFlicking";
+export * from "./CrossFlicking";
 export * from "./core";
 export * from "./camera";
 export * from "./control";
@@ -9,5 +11,5 @@ export * from "./cfc";
 export * from "./utils";
 export * from "./type/event";
 export * from "./type/external";
-export type { FlickingOptions, FlickingEvents };
+export type { FlickingOptions, FlickingEvents, CrossFlickingOptions };
 export default Flicking;

package/declaration/utils.d.ts

@@ -43,3 +43,5 @@ export declare const getElementSize: ({ el, horizontal, useFractionalSize, useOf
     style: CSSStyleDeclaration;
 }) => number;
 export declare const setPrototypeOf: (o: any, proto: object) => any;
+export declare const camelize: (str: string) => string;
+export declare const getDataAttributes: (element: HTMLElement, attributePrefix: string) => Record<string, string>;

package/dist/flicking.cjs.js

@@ -4,7 +4,7 @@ name: @egjs/flicking
 license: MIT
 author: NAVER Corp.
 repository: https://github.com/naver/egjs-flicking
-version: 4.12.0-beta.0
+version: 4.12.0-beta.10
 */
 'use strict';
 
@@ -387,6 +387,8 @@ var MOVE_TYPE = {
   STRICT: "strict"
 };
 var CLASS = {
+  VIEWPORT: "flicking-viewport",
+  CAMERA: "flicking-camera",
   VERTICAL: "vertical",
   HIDDEN: "flicking-hidden",
   DEFAULT_VIRTUAL: "flicking-panel"
@@ -413,6 +415,17 @@ var ORDER = {
   LTR: "ltr",
   RTL: "rtl"
 };
+/**
+ * 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>
+ */
+var MOVE_DIRECTION = {
+  HORIZONTAL: "horizontal",
+  VERTICAL: "vertical"
+};
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 var merge = function (target) {
@@ -727,6 +740,26 @@ var setPrototypeOf = Object.setPrototypeOf || function (obj, proto) {
   obj.__proto__ = proto;
   return obj;
 };
+var camelize = function (str) {
+  return str.replace(/[\s-_]([a-z])/g, function (all, letter) {
+    return letter.toUpperCase();
+  });
+};
+var getDataAttributes = function (element, attributePrefix) {
+  var dataAttributes = {};
+  var attributes = element.attributes;
+  var length = attributes.length;
+  for (var i = 0; i < length; ++i) {
+    var attribute = attributes[i];
+    var name_1 = attribute.name,
+      value = attribute.value;
+    if (name_1.indexOf(attributePrefix) === -1) {
+      continue;
+    }
+    dataAttributes[camelize(name_1.replace(attributePrefix, ""))] = value;
+  }
+  return dataAttributes;
+};
 
 /*
  * Copyright (c) 2015 NAVER Corp.
@@ -3713,6 +3746,7 @@ var Camera = /*#__PURE__*/function () {
     var _this = this;
     var _b = (_a === void 0 ? {} : _a).align,
       align = _b === void 0 ? ALIGN.CENTER : _b;
+    this._lookedOffset = 0;
     this._checkTranslateSupport = function () {
       var e_1, _a;
       var transforms = ["webkitTransform", "msTransform", "MozTransform", "OTransform", "transform"];
@@ -4072,6 +4106,8 @@ var Camera = /*#__PURE__*/function () {
    */
   __proto.lookAt = function (pos) {
     var _this = this;
+    var prevOffset = this._offset;
+    var isChangedOffset = this._lookedOffset !== prevOffset;
     var flicking = getFlickingAttached(this._flicking);
     var prevPos = this._position;
     this._position = pos;
@@ -4082,7 +4118,12 @@ var Camera = /*#__PURE__*/function () {
     if (toggled) {
       void flicking.renderer.render().then(function () {
         _this.updateOffset();
+        _this._lookedOffset = _this._offset;
       });
+    } else if (isChangedOffset) {
+      // sync offset for renderOnlyVisible on resize
+      this.updateOffset();
+      this._lookedOffset = this._offset;
     } else {
       this.applyTransform();
     }
@@ -4257,8 +4298,8 @@ var Camera = /*#__PURE__*/function () {
     return this;
   };
   /**
-   * Update Viewport's height to active panel's height
-   * @ko 현재 선택된 패널의 높이와 동일하도록 뷰포트의 높이를 업데이트합니다
+   * Update Viewport's height to visible panel's max height
+   * @ko 현재 활성화된 패널과 보이는 패널의 최대 높이와 동일하도록 뷰포트의 높이를 업데이트합니다
    * @throws {FlickingError}
    * {@link ERROR_CODE NOT_ATTACHED_TO_FLICKING} When {@link Camera#init init} is not called before
    * <ko>{@link ERROR_CODE NOT_ATTACHED_TO_FLICKING} {@link Camera#init init}이 이전에 호출되지 않은 경우</ko>
@@ -4268,9 +4309,17 @@ var Camera = /*#__PURE__*/function () {
   __proto.updateAdaptiveHeight = function () {
     var flicking = getFlickingAttached(this._flicking);
     var activePanel = flicking.control.activePanel;
-    if (!flicking.horizontal || !flicking.adaptive || !activePanel) return;
+    var visiblePanels = flicking.visiblePanels;
+    var selectedPanels = __spread(visiblePanels);
+    if (activePanel) {
+      selectedPanels.push(activePanel);
+    }
+    if (!flicking.horizontal || !flicking.adaptive || !selectedPanels.length) return;
+    var maxHeight = Math.max.apply(Math, __spread(selectedPanels.map(function (panel) {
+      return panel.height;
+    })));
     flicking.viewport.setSize({
-      height: activePanel.height
+      height: maxHeight
     });
   };
   /**
@@ -4341,6 +4390,7 @@ var Camera = /*#__PURE__*/function () {
   };
   __proto._resetInternalValues = function () {
     this._position = 0;
+    this._lookedOffset = 0;
     this._alignPos = 0;
     this._offset = 0;
     this._circularOffset = 0;
@@ -7862,10 +7912,336 @@ var Flicking = /*#__PURE__*/function (_super) {
    * Flicking.VERSION;  // ex) 4.0.0
    * ```
    */
-  Flicking.VERSION = "4.12.0-beta.0";
+  Flicking.VERSION = "4.12.0-beta.10";
   return Flicking;
 }(Component);
 
+var SIDE_EVENTS = {
+  HOLD_START: "sideHoldStart",
+  HOLD_END: "sideHoldEnd",
+  MOVE_START: "sideMoveStart",
+  MOVE: "sideMove",
+  MOVE_END: "sideMoveEnd",
+  WILL_CHANGE: "sideWillChange",
+  CHANGED: "sideChanged"
+};
+var CrossFlicking = /*#__PURE__*/function (_super) {
+  __extends(CrossFlicking, _super);
+  function CrossFlicking(root, options) {
+    var _this = _super.call(this, root, options) || this;
+    _this._syncToCategory = function (index, outerIndex) {
+      if (_this._disableIndexSync) {
+        return;
+      }
+      _this.stopAnimation();
+      _this._sideFlicking.forEach(function (child, i) {
+        var _a = _this._sideState[i],
+          start = _a.start,
+          end = _a.end;
+        if (start <= index && end >= index && outerIndex !== i) {
+          child.stopAnimation();
+          void child.moveTo(index, 0);
+          void _this.moveTo(i, 0);
+        }
+      });
+    };
+    _this._setDraggable = function (direction, draggable) {
+      if (!_this._disableSlideOnHold) {
+        return;
+      }
+      var dragThreshold = _this._originalDragThreshold;
+      var threshold = draggable ? dragThreshold && dragThreshold >= 10 ? dragThreshold : 10 : Infinity;
+      if (direction === MOVE_DIRECTION.HORIZONTAL === _this.horizontal) {
+        _this.dragThreshold = threshold;
+      } else if (direction === MOVE_DIRECTION.VERTICAL === _this.horizontal) {
+        _this._sideFlicking.forEach(function (child) {
+          child.dragThreshold = threshold;
+        });
+      }
+    };
+    _this._setPreviousSideIndex = function () {
+      _this._sideFlicking.forEach(function (child, i) {
+        var _a = _this._sideState[i],
+          start = _a.start,
+          end = _a.end;
+        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);
+          }
+        }
+      });
+    };
+    _this._onHorizontalHoldStart = function () {
+      _this._setDraggable(MOVE_DIRECTION.HORIZONTAL, true);
+      _this._moveDirection = null;
+    };
+    _this._onHorizontalMove = function (e) {
+      if (e.isTrusted && !_this._moveDirection) {
+        _this._setDraggable(MOVE_DIRECTION.VERTICAL, false);
+        _this._moveDirection = MOVE_DIRECTION.HORIZONTAL;
+      }
+    };
+    _this._onHorizontalMoveEnd = function (e) {
+      var visiblePanels = _this.visiblePanels;
+      if (visiblePanels.length > 1) {
+        _this._nextIndex = e.direction === "NEXT" ? visiblePanels[1].index : visiblePanels[0].index;
+      } else {
+        _this._nextIndex = visiblePanels[0].index;
+      }
+      _this._setDraggable(MOVE_DIRECTION.VERTICAL, true);
+      _this._moveDirection = null;
+      // _syncToCategory에서 완전히 가로 이동이 이루어지기 전에 세로 방향 index가 변하는 경우가 있어 requestAnimationFrame 처리
+      requestAnimationFrame(function () {
+        return _this._setPreviousSideIndex();
+      });
+      if (e.isTrusted) {
+        _this._syncToCategory(_this._sideFlicking[_this._nextIndex].index, _this._nextIndex);
+      }
+    };
+    _this._onSideHoldStart = function () {
+      _this._setDraggable(MOVE_DIRECTION.VERTICAL, true);
+      _this._moveDirection = null;
+    };
+    _this._onSideMove = function (e) {
+      if (e.isTrusted && !_this._moveDirection) {
+        _this._setDraggable(MOVE_DIRECTION.HORIZONTAL, false);
+        _this._moveDirection = MOVE_DIRECTION.VERTICAL;
+      }
+    };
+    _this._onSideMoveEnd = function () {
+      _this._setDraggable(MOVE_DIRECTION.HORIZONTAL, true);
+      _this._moveDirection = null;
+    };
+    _this._onSideChanged = function (e) {
+      // 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) {
+        _this._syncToCategory(e.index, _this.index);
+      }
+    };
+    var _a = options.sideOptions,
+      sideOptions = _a === void 0 ? {} : _a,
+      _b = options.preserveIndex,
+      preserveIndex = _b === void 0 ? true : _b,
+      _c = options.disableSlideOnHold,
+      disableSlideOnHold = _c === void 0 ? true : _c,
+      _d = options.disableIndexSync,
+      disableIndexSync = _d === void 0 ? false : _d;
+    // Internal states
+    _this._moveDirection = null;
+    _this._nextIndex = 0;
+    _this._originalDragThreshold = _this.dragThreshold;
+    // Bind options
+    _this._sideOptions = sideOptions;
+    _this._preserveIndex = preserveIndex;
+    _this._disableSlideOnHold = disableSlideOnHold;
+    _this._disableIndexSync = disableIndexSync;
+    return _this;
+  }
+  var __proto = CrossFlicking.prototype;
+  Object.defineProperty(__proto, "sideFlicking", {
+    // Components
+    get: function () {
+      return this._sideFlicking;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "sideState", {
+    get: function () {
+      return this._sideState;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "sideOptions", {
+    // Options Getter
+    get: function () {
+      return this._sideOptions;
+    },
+    // Options Setter
+    set: function (val) {
+      this._sideOptions = val;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "preserveIndex", {
+    get: function () {
+      return this._preserveIndex;
+    },
+    set: function (val) {
+      this._preserveIndex = val;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "disableSlideOnHold", {
+    get: function () {
+      return this._disableSlideOnHold;
+    },
+    set: function (val) {
+      this._disableSlideOnHold = val;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(__proto, "disableIndexSync", {
+    get: function () {
+      return this._disableIndexSync;
+    },
+    set: function (val) {
+      this._disableIndexSync = val;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  __proto.init = function () {
+    var _this = this;
+    return _super.prototype.init.call(this).then(function () {
+      _this._sideState = _this._createSideState();
+      _this._sideFlicking = _this._createSideFlicking();
+      _this._addComponentEvents();
+    });
+  };
+  __proto.destroy = function () {
+    this._sideFlicking.forEach(function (flicking) {
+      flicking.destroy();
+    });
+    _super.prototype.destroy.call(this);
+  };
+  __proto._addComponentEvents = function () {
+    var _this = this;
+    this.on(EVENTS.HOLD_START, this._onHorizontalHoldStart);
+    this.on(EVENTS.MOVE, this._onHorizontalMove);
+    this.on(EVENTS.MOVE_END, this._onHorizontalMoveEnd);
+    this._sideFlicking.forEach(function (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(function (name) {
+        flicking.on(EVENTS[name], function (event) {
+          _this.trigger(new Component.ComponentEvent(SIDE_EVENTS[name], __assign({
+            mainIndex: mainIndex
+          }, event)));
+        });
+      });
+    });
+  };
+  __proto._createSideState = function () {
+    var viewportEl = this.element;
+    var cameraEl = this.camera.element;
+    var panels = toArray(cameraEl.children);
+    var isCrossStructure = getDataAttributes(viewportEl, "data-cross-").structure;
+    var sideState = [];
+    if (!isCrossStructure) {
+      var groupPanels = this._getGroupFromAttribute(panels);
+      var 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;
+  };
+  __proto._createCrossStructure = function (sideState) {
+    var _this = this;
+    var sideCamera = document.createElement("div");
+    var sidePanels = "";
+    sideCamera.classList.add(CLASS.CAMERA);
+    sideState.forEach(function (state, i) {
+      var panel = _this.camera.children[i];
+      sidePanels += state.element.innerHTML;
+      Array.from(panel.attributes).forEach(function (attribute) {
+        return panel.removeAttribute(attribute.name);
+      });
+    });
+    sideCamera.innerHTML = sidePanels;
+    sideState.forEach(function (_, i) {
+      var panel = _this.camera.children[i];
+      [CLASS.VIEWPORT, CLASS.VERTICAL].forEach(function (className) {
+        if (!panel.classList.contains(className)) {
+          panel.classList.add(className);
+        }
+      });
+      panel.innerHTML = sideCamera.outerHTML;
+    });
+    this.element.setAttribute("data-cross-structure", "true");
+  };
+  __proto._getGroupFromAttribute = function (panels) {
+    var groupKeys = [];
+    var groupPanels = {};
+    panels.forEach(function (panel) {
+      var groupKey = getDataAttributes(panel, "data-cross-").groupkey;
+      if (groupKey && !includes(groupKeys, groupKey)) {
+        groupKeys.push(groupKey);
+        groupPanels[groupKey] = [panel];
+      } else if (groupKey) {
+        groupPanels[groupKey].push(panel);
+      }
+    });
+    return groupPanels;
+  };
+  __proto._getSideStateFromGroup = function (groupPanels) {
+    return Object.keys(groupPanels).reduce(function (state, key) {
+      var start = state.length ? +state[state.length - 1].end + 1 : 0;
+      var element = groupPanels[key].reduce(function (el, panel) {
+        el.innerHTML += panel.outerHTML;
+        return el;
+      }, document.createElement("div"));
+      return __spread(state, [{
+        key: key,
+        start: start,
+        end: start + groupPanels[key].length - 1,
+        element: element
+      }]);
+    }, []);
+  };
+  __proto._getSideStateFromPanels = function (panels) {
+    return panels.reduce(function (state, panel, i) {
+      var start = state.length ? +state[state.length - 1].end + 1 : 0;
+      return __spread(state, [{
+        key: i.toString(),
+        start: start,
+        end: start + panel.children.length - 1,
+        element: panel
+      }]);
+    }, []);
+  };
+  __proto._getSideStateFromCrossStructure = function (panels) {
+    var groupPanels = this._getGroupFromAttribute(panels);
+    return this._getSideStateFromGroup(groupPanels);
+  };
+  __proto._createSideFlicking = function () {
+    var _this = this;
+    return this.sideState.map(function (state, i) {
+      return new Flicking(_this.camera.children[i], __assign(__assign({}, _this.sideOptions), {
+        horizontal: false,
+        panelsPerView: 1,
+        defaultIndex: state.start
+      }));
+    });
+  };
+  return CrossFlicking;
+}(Flicking);
+
 /**
  * Decorator that makes the method of flicking available in the framework.
  * @ko 프레임워크에서 플리킹의 메소드를 사용할 수 있게 하는 데코레이터.
@@ -8083,6 +8459,8 @@ var parseAlign = function (alignVal) {
 var modules = {
     __proto__: null,
     'default': Flicking,
+    SIDE_EVENTS: SIDE_EVENTS,
+    CrossFlicking: CrossFlicking,
     VanillaElementProvider: VanillaElementProvider,
     VirtualElementProvider: VirtualElementProvider,
     Panel: Panel,
@@ -8120,6 +8498,7 @@ var modules = {
     CLASS: CLASS,
     CIRCULAR_FALLBACK: CIRCULAR_FALLBACK,
     ORDER: ORDER,
+    MOVE_DIRECTION: MOVE_DIRECTION,
     withFlickingMethods: withFlickingMethods,
     sync: sync,
     getRenderingPanels: getRenderingPanels,
@@ -8152,7 +8531,9 @@ var modules = {
     circulateIndex: circulateIndex,
     range: range,
     getElementSize: getElementSize,
-    setPrototypeOf: setPrototypeOf
+    setPrototypeOf: setPrototypeOf,
+    camelize: camelize,
+    getDataAttributes: getDataAttributes
 };
 
 /*
@@ -8174,6 +8555,7 @@ exports.CLASS = CLASS;
 exports.Camera = Camera;
 exports.CircularCameraMode = CircularCameraMode;
 exports.Control = Control;
+exports.CrossFlicking = CrossFlicking;
 exports.DIRECTION = DIRECTION;
 exports.DisabledState = DisabledState;
 exports.DraggingState = DraggingState;
@@ -8185,11 +8567,13 @@ exports.FreeControl = FreeControl;
 exports.HoldingState = HoldingState;
 exports.IdleState = IdleState;
 exports.LinearCameraMode = LinearCameraMode;
+exports.MOVE_DIRECTION = MOVE_DIRECTION;
 exports.MOVE_TYPE = MOVE_TYPE;
 exports.NormalRenderingStrategy = NormalRenderingStrategy;
 exports.ORDER = ORDER;
 exports.Panel = Panel;
 exports.Renderer = Renderer;
+exports.SIDE_EVENTS = SIDE_EVENTS;
 exports.SnapControl = SnapControl;
 exports.State = State;
 exports.StateMachine = StateMachine;
@@ -8201,6 +8585,7 @@ exports.VirtualElementProvider = VirtualElementProvider;
 exports.VirtualManager = VirtualManager;
 exports.VirtualPanel = VirtualPanel;
 exports.VirtualRenderingStrategy = VirtualRenderingStrategy;
+exports.camelize = camelize;
 exports.checkExistence = checkExistence;
 exports.circulateIndex = circulateIndex;
 exports.circulatePosition = circulatePosition;
@@ -8209,6 +8594,7 @@ exports["default"] = Flicking;
 exports.find = find;
 exports.findIndex = findIndex;
 exports.findRight = findRight;
+exports.getDataAttributes = getDataAttributes;
 exports.getDefaultCameraTransform = getDefaultCameraTransform;
 exports.getDirection = getDirection;
 exports.getElement = getElement;