@egjs/vue3-flicking 4.15.0 → 4.16.0-beta.10

package/dist/flicking.cjs.js

@@ -1,230 +1,9 @@
-/*
-Copyright (c) NAVER Corp.
-name: @egjs/vue3-flicking
-license: MIT
-author: NAVER Corp.
-repository: https://github.com/naver/egjs-flicking/tree/master/packages/vue3-flicking
-version: 4.15.0
-*/
-'use strict';
-
-var vue = require('vue');
-var ListDiffer = require('@egjs/list-differ');
-var Component = require('@egjs/component');
-var VanillaFlicking = require('@egjs/flicking');
-var vue3 = require('@cfcs/vue3');
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-/* global Reflect, Promise */
-var extendStatics = function (d, b) {
-  extendStatics = Object.setPrototypeOf || {
-    __proto__: []
-  } instanceof Array && function (d, b) {
-    d.__proto__ = b;
-  } || function (d, b) {
-    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
-  };
-
-  return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-  extendStatics(d, b);
-
-  function __() {
-    this.constructor = d;
-  }
-
-  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-var __assign = function () {
-  __assign = Object.assign || function __assign(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-      s = arguments[i];
-
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-    }
-
-    return t;
-  };
-
-  return __assign.apply(this, arguments);
-};
-function __rest(s, e) {
-  var t = {};
-
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-
-  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-  }
-  return t;
-}
-function __awaiter(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
-  }
-
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-}
-function __generator(thisArg, body) {
-  var _ = {
-    label: 0,
-    sent: function () {
-      if (t[0] & 1) throw t[1];
-      return t[1];
-    },
-    trys: [],
-    ops: []
-  },
-      f,
-      y,
-      t,
-      g;
-  return g = {
-    next: verb(0),
-    "throw": verb(1),
-    "return": verb(2)
-  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
-    return this;
-  }), g;
-
-  function verb(n) {
-    return function (v) {
-      return step([n, v]);
-    };
-  }
-
-  function step(op) {
-    if (f) throw new TypeError("Generator is already executing.");
-
-    while (_) try {
-      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-      if (y = 0, t) op = [op[0] & 2, t.value];
-
-      switch (op[0]) {
-        case 0:
-        case 1:
-          t = op;
-          break;
-
-        case 4:
-          _.label++;
-          return {
-            value: op[1],
-            done: false
-          };
-
-        case 5:
-          _.label++;
-          y = op[1];
-          op = [0];
-          continue;
-
-        case 7:
-          op = _.ops.pop();
-
-          _.trys.pop();
-
-          continue;
-
-        default:
-          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-            _ = 0;
-            continue;
-          }
-
-          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-            _.label = op[1];
-            break;
-          }
-
-          if (op[0] === 6 && _.label < t[1]) {
-            _.label = t[1];
-            t = op;
-            break;
-          }
-
-          if (t && _.label < t[2]) {
-            _.label = t[2];
-
-            _.ops.push(op);
-
-            break;
-          }
-
-          if (t[2]) _.ops.pop();
-
-          _.trys.pop();
-
-          continue;
-      }
-
-      op = body.call(thisArg, _);
-    } catch (e) {
-      op = [6, e];
-      y = 0;
-    } finally {
-      f = t = 0;
-    }
-
-    if (op[0] & 5) throw op[1];
-    return {
-      value: op[0] ? op[1] : void 0,
-      done: true
-    };
-  }
-}
-function __spreadArray(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-var FlickingProps = {
+"use strict";
+const Component = require("@egjs/component");
+const VanillaFlicking = require("@egjs/flicking");
+const ListDiffer = require("@egjs/list-differ");
+const vue = require("vue");
+const FlickingProps = {
   viewportTag: {
     type: String,
     default: "div",
@@ -251,16 +30,12 @@ var FlickingProps = {
   },
   options: {
     type: Object,
-    default: function () {
-      return {};
-    },
+    default: () => ({}),
     required: false
   },
   plugins: {
     type: Array,
-    default: function () {
-      return [];
-    },
+    default: () => [],
     required: false
   },
   status: {
@@ -268,388 +43,250 @@ var FlickingProps = {
     required: false
   }
 };
-
-var VueRenderer =
-/*#__PURE__*/
-function (_super) {
-  __extends(VueRenderer, _super);
-
-  function VueRenderer(options) {
-    var _this = _super.call(this, options) || this;
-
-    _this._vueFlicking = options.vueFlicking;
-    return _this;
+class VueElementProvider {
+  get rendered() {
+    return !this._el.hide;
   }
-
-  var __proto = VueRenderer.prototype;
-
-  __proto.render = function () {
-    return __awaiter(this, void 0, void 0, function () {
-      var flicking, vueFlicking, strategy;
-
-      var _this = this;
-
-      return __generator(this, function (_a) {
-        flicking = VanillaFlicking.getFlickingAttached(this._flicking);
-        vueFlicking = this._vueFlicking;
-        strategy = this._strategy;
-        strategy.updateRenderingPanels(flicking);
-        strategy.renderPanels(flicking);
-        return [2
-        /*return*/
-        , new Promise(function (resolve) {
-          vueFlicking.renderEmitter.once("render", function () {
-            _this._afterRender();
-
-            resolve();
-          });
-          vueFlicking.$forceUpdate();
-        })];
-      });
-    });
-  };
-
-  __proto.forceRenderAllPanels = function () {
-    return __awaiter(this, void 0, void 0, function () {
-      var vueFlicking;
-      return __generator(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            vueFlicking = this._vueFlicking;
-            return [4
-            /*yield*/
-            , _super.prototype.forceRenderAllPanels.call(this)];
-
-          case 1:
-            _a.sent();
-
-            return [2
-            /*return*/
-            , new Promise(function (resolve) {
-              vueFlicking.renderEmitter.once("render", resolve);
-              vueFlicking.$forceUpdate();
-            })];
-        }
-      });
-    });
-  };
-
-  __proto._collectPanels = function () {
-    var flicking = VanillaFlicking.getFlickingAttached(this._flicking);
-    var vueFlicking = this._vueFlicking;
-    var childRefs = vueFlicking.$refs;
-    var vuePanels = Object.keys(childRefs).map(function (refKey) {
-      return childRefs[refKey];
-    });
-    this._panels = this._strategy.collectPanels(flicking, vuePanels);
-  };
-
-  __proto._createPanel = function (externalComponent, options) {
-    return this._strategy.createPanel(externalComponent, options);
-  };
-
-  return VueRenderer;
-}(VanillaFlicking.ExternalRenderer);
-
-/*
- * Copyright (c) 2015 NAVER Corp.
- * egjs projects are licensed under the MIT license
- */
-var VuePanel = vue.defineComponent({
-  data: function () {
+  get element() {
+    const el = this._el.$el.nextSibling;
+    if (el && el.nodeType === Node.ELEMENT_NODE) {
+      this._cachedElement = el;
+    }
+    return this._cachedElement;
+  }
+  constructor(el) {
+    this._el = el;
+  }
+  show() {
+    this._el.hide = false;
+  }
+  hide() {
+    this._el.hide = true;
+  }
+}
+const VuePanel = vue.defineComponent({
+  data() {
     return {
       hide: false
     };
   },
-  render: function () {
+  render() {
     if (this.hide || !this.$slots.default) return;
     return this.$slots.default();
   }
 });
-
-var VueElementProvider =
-/*#__PURE__*/
-function () {
-  function VueElementProvider(el) {
-    this._el = el;
+class VueRenderer extends VanillaFlicking.ExternalRenderer {
+  constructor(options) {
+    super(options);
+    this._vueFlicking = options.vueFlicking;
   }
-
-  var __proto = VueElementProvider.prototype;
-  Object.defineProperty(__proto, "rendered", {
-    get: function () {
-      return !this._el.hide;
-    },
-    enumerable: false,
-    configurable: true
-  });
-  Object.defineProperty(__proto, "element", {
-    get: function () {
-      var el = this._el.$el.nextSibling;
-
-      if (el && el.nodeType === Node.ELEMENT_NODE) {
-        this._cachedElement = el;
-      }
-
-      return this._cachedElement;
-    },
-    enumerable: false,
-    configurable: true
-  });
-
-  __proto.show = function () {
-    this._el.hide = false;
-  };
-
-  __proto.hide = function () {
-    this._el.hide = true;
-  };
-
-  return VueElementProvider;
-}();
-
-var Flicking = vue.defineComponent({
+  async render() {
+    const flicking = VanillaFlicking.getFlickingAttached(this._flicking);
+    const vueFlicking = this._vueFlicking;
+    const strategy = this._strategy;
+    strategy.updateRenderingPanels(flicking);
+    strategy.renderPanels(flicking);
+    return new Promise((resolve) => {
+      vueFlicking.renderEmitter.once("render", () => {
+        this._afterRender();
+        resolve();
+      });
+      vueFlicking.$forceUpdate();
+    });
+  }
+  async forceRenderAllPanels() {
+    const vueFlicking = this._vueFlicking;
+    await super.forceRenderAllPanels();
+    return new Promise((resolve) => {
+      vueFlicking.renderEmitter.once("render", resolve);
+      vueFlicking.$forceUpdate();
+    });
+  }
+  _collectPanels() {
+    const flicking = VanillaFlicking.getFlickingAttached(this._flicking);
+    const vueFlicking = this._vueFlicking;
+    const childRefs = vueFlicking.$refs;
+    const vuePanels = Object.keys(childRefs).map((refKey) => childRefs[refKey]);
+    this._panels = this._strategy.collectPanels(flicking, vuePanels);
+  }
+  _createPanel(externalComponent, options) {
+    return this._strategy.createPanel(externalComponent, options);
+  }
+}
+const Flicking = vue.defineComponent({
   props: FlickingProps,
   components: {
     Panel: VuePanel
   },
-  data: function () {
+  data() {
     return {};
   },
-  created: function () {
-    var _this = this;
-
+  created() {
     this.vanillaFlicking = null;
     this.renderEmitter = new Component();
     this.diffResult = null;
-
-    this.getPanels = function () {
-      var componentInstance = vue.getCurrentInstance();
-      var vueFlicking = componentInstance === null || componentInstance === void 0 ? void 0 : componentInstance.ctx;
-      var flicking = _this.vanillaFlicking;
-
-      var defaultSlots = _this.getSlots();
-
-      var diffResult = vueFlicking === null || vueFlicking === void 0 ? void 0 : vueFlicking.diffResult;
-      var slots = diffResult ? VanillaFlicking.getRenderingPanels(flicking, diffResult) : defaultSlots;
-      var panelComponent = vue.resolveComponent("Panel");
-      var panels = slots.map(function (slot, idx) {
-        return vue.h(panelComponent, {
-          key: slot.key,
-          ref: idx.toString()
-        }, function () {
-          return slot;
-        });
-      });
+    this.getPanels = () => {
+      const componentInstance = vue.getCurrentInstance();
+      const vueFlicking = componentInstance?.ctx;
+      const flicking = this.vanillaFlicking;
+      const defaultSlots = this.getSlots();
+      const diffResult = vueFlicking?.diffResult;
+      const slots = diffResult ? VanillaFlicking.getRenderingPanels(flicking, diffResult) : defaultSlots;
+      const panelComponent = vue.resolveComponent("Panel");
+      const panels = slots.map(
+        (slot, idx) => vue.h(
+          panelComponent,
+          {
+            key: slot.key,
+            ref: idx.toString()
+          },
+          () => slot
+        )
+      );
       return panels;
     };
-
-    this.getVirtualPanels = function () {
-      var options = _this.options;
-      var _a = options.virtual.panelClass,
-          panelClass = _a === void 0 ? "flicking-panel" : _a;
-      var panelsPerView = options.panelsPerView;
-      var flicking = _this.vanillaFlicking;
-      var initialized = flicking && flicking.initialized;
-      var renderingIndexes = initialized ? flicking.renderer.strategy.getRenderingIndexesByOrder(flicking) : VanillaFlicking.range(panelsPerView + 1);
-      var firstPanel = initialized && flicking.panels[0];
-      var size = firstPanel ? flicking.horizontal ? {
-        width: firstPanel.size
-      } : {
-        height: firstPanel.size
-      } : {};
-      return renderingIndexes.map(function (idx) {
-        return vue.h("div", {
+    this.getVirtualPanels = () => {
+      const options = this.options;
+      const { panelClass = "flicking-panel" } = options.virtual;
+      const panelsPerView = options.panelsPerView;
+      const flicking = this.vanillaFlicking;
+      const initialized = flicking?.initialized;
+      const renderingIndexes = initialized ? flicking.renderer.strategy.getRenderingIndexesByOrder(flicking) : VanillaFlicking.range(panelsPerView + 1);
+      const firstPanel = initialized && flicking.panels[0];
+      const size = firstPanel ? flicking.horizontal ? { width: firstPanel.size } : { height: firstPanel.size } : {};
+      return renderingIndexes.map(
+        (idx) => vue.h("div", {
           key: idx,
           ref: idx.toString(),
           class: panelClass,
           style: size,
           "data-element-index": idx
-        });
-      });
+        })
+      );
     };
-
     VanillaFlicking.withFlickingMethods(this, "vanillaFlicking");
   },
-  mounted: function () {
-    var _this = this;
-
-    var _a;
-
-    var options = this.options;
-    var viewportEl = this.$el;
-    var rendererOptions = {
+  mounted() {
+    const options = this.options;
+    const viewportEl = this.$el;
+    const rendererOptions = {
       vueFlicking: this,
       align: options.align,
-      strategy: options.virtual && ((_a = options.panelsPerView) !== null && _a !== void 0 ? _a : -1) > 0 ? new VanillaFlicking.VirtualRenderingStrategy() : new VanillaFlicking.NormalRenderingStrategy({
+      strategy: options.virtual && (options.panelsPerView ?? -1) > 0 ? new VanillaFlicking.VirtualRenderingStrategy() : new VanillaFlicking.NormalRenderingStrategy({
         providerCtor: VueElementProvider
       })
     };
-    var flicking = new VanillaFlicking(viewportEl, __assign(__assign({}, options), {
+    const flicking = new VanillaFlicking(viewportEl, {
+      ...options,
       externalRenderer: new VueRenderer(rendererOptions)
-    }));
-    this.vanillaFlicking = flicking;
-    flicking.once(VanillaFlicking.EVENTS.READY, function () {
-      _this.$forceUpdate();
     });
-    var slots = this.getSlots();
-    this.slotDiffer = new ListDiffer(slots, function (vnode) {
-      return vnode.key;
+    this.vanillaFlicking = flicking;
+    flicking.once(VanillaFlicking.EVENTS.READY, () => {
+      this.$forceUpdate();
     });
+    const slots = this.getSlots();
+    this.slotDiffer = new ListDiffer(slots, (vnode) => vnode.key);
     this.pluginsDiffer = new ListDiffer();
     this.bindEvents();
     this.checkPlugins();
-
     if (this.status) {
       flicking.setStatus(this.status);
     }
   },
-  beforeUnmount: function () {
-    var _a;
-
-    (_a = this.vanillaFlicking) === null || _a === void 0 ? void 0 : _a.destroy();
+  beforeUnmount() {
+    this.vanillaFlicking?.destroy();
   },
-  beforeMount: function () {
+  beforeMount() {
     this.fillKeys();
   },
-  beforeUpdate: function () {
-    var _a;
-
+  beforeUpdate() {
     this.fillKeys();
-    this.diffResult = (_a = this.slotDiffer) === null || _a === void 0 ? void 0 : _a.update(this.getSlots());
+    this.diffResult = this.slotDiffer?.update(this.getSlots());
   },
-  updated: function () {
-    var flicking = this.vanillaFlicking;
-    var diffResult = this.diffResult;
+  updated() {
+    const flicking = this.vanillaFlicking;
+    const diffResult = this.diffResult;
     this.checkPlugins();
     this.renderEmitter.trigger("render");
-    if (!diffResult || !(flicking === null || flicking === void 0 ? void 0 : flicking.initialized)) return;
-    var children = this.getChildren();
+    if (!diffResult || !flicking?.initialized) return;
+    const children = this.getChildren();
     VanillaFlicking.sync(flicking, diffResult, children);
-
     if (diffResult.added.length > 0 || diffResult.removed.length > 0) {
       this.$forceUpdate();
     }
-
-    this.diffResult = undefined;
+    this.diffResult = void 0;
   },
-  render: function () {
-    var _a;
-
-    var _b;
-
-    var flicking = this.vanillaFlicking;
-    var options = this.options;
-    var initialized = flicking && flicking.initialized;
-    var isHorizontal = flicking ? flicking.horizontal : (_b = this.options.horizontal) !== null && _b !== void 0 ? _b : true;
-    var viewportData = {
+  render() {
+    const flicking = this.vanillaFlicking;
+    const options = this.options;
+    const initialized = flicking?.initialized;
+    const isHorizontal = flicking ? flicking.horizontal : this.options.horizontal ?? true;
+    const viewportData = {
       class: {
         "flicking-viewport": true,
-        "vertical": !isHorizontal,
+        vertical: !isHorizontal,
         "flicking-hidden": this.hideBeforeInit && !initialized
       }
     };
-    var cameraData = {
-      class: (_a = {
-        "flicking-camera": true
-      }, _a[this.cameraClass] = !!this.cameraClass, _a),
-      style: !initialized && this.firstPanelSize ? {
-        transform: VanillaFlicking.getDefaultCameraTransform(this.options.align, this.options.horizontal, this.firstPanelSize)
-      } : {}
+    const cameraData = {
+      class: {
+        "flicking-camera": true,
+        [this.cameraClass]: !!this.cameraClass
+      },
+      style: !initialized && this.firstPanelSize ? { transform: VanillaFlicking.getDefaultCameraTransform(this.options.align, this.options.horizontal, this.firstPanelSize) } : {}
     };
-    var panels = options.virtual && options.panelsPerView && options.panelsPerView > 0 ? this.getVirtualPanels : this.getPanels;
-    var viewportSlots = this.$slots.viewport ? this.$slots.viewport() : [];
-    return vue.h(this.viewportTag, viewportData, __spreadArray([vue.h(this.cameraTag, cameraData, {
-      default: panels
-    })], viewportSlots, true));
+    const panels = options.virtual && options.panelsPerView && options.panelsPerView > 0 ? this.getVirtualPanels : this.getPanels;
+    const viewportSlots = this.$slots.viewport ? this.$slots.viewport() : [];
+    return vue.h(this.viewportTag, viewportData, [vue.h(this.cameraTag, cameraData, { default: panels }), ...viewportSlots]);
   },
   methods: {
-    getSlots: function () {
-      var _this = this;
-
-      var slots = this.$slots.default ? this.$slots.default() : [];
-      return slots.reduce(function (elementSlots, slot) {
-        return __spreadArray(__spreadArray([], elementSlots, true), _this.getElementVNodes(slot), true);
-      }, []).filter(function (slot) {
-        return slot.type !== vue.Comment && slot.type !== vue.Text;
-      });
+    getSlots() {
+      const slots = this.$slots.default ? this.$slots.default() : [];
+      return slots.reduce((elementSlots, slot) => [...elementSlots, ...this.getElementVNodes(slot)], []).filter((slot) => slot.type !== vue.Comment && slot.type !== vue.Text);
     },
-    getElementVNodes: function (slot, childSlots) {
-      var _this = this;
-
-      if (childSlots === void 0) {
-        childSlots = [];
-      }
-
+    getElementVNodes(slot, childSlots = []) {
       if (slot.type === vue.Fragment && Array.isArray(slot.children)) {
-        slot.children.filter(function (child) {
-          return child && typeof child === "object";
-        }).forEach(function (child) {
-          return _this.getElementVNodes(child, childSlots);
-        });
+        slot.children.filter((child) => child && typeof child === "object").forEach((child) => this.getElementVNodes(child, childSlots));
       } else {
         childSlots.push(slot);
       }
-
       return childSlots;
     },
-    bindEvents: function () {
-      var _this = this;
-
-      var flicking = this.vanillaFlicking;
-      var events = Object.keys(VanillaFlicking.EVENTS).map(function (key) {
-        return VanillaFlicking.EVENTS[key];
-      });
-      events.forEach(function (eventName) {
-        flicking.on(eventName, function (e) {
-          e.currentTarget = _this; // Make events from camelCase to kebab-case
-
-          _this.$emit(eventName.replace(/([A-Z])/g, "-$1").toLowerCase(), e);
+    bindEvents() {
+      const flicking = this.vanillaFlicking;
+      const events = Object.keys(VanillaFlicking.EVENTS).map((key) => VanillaFlicking.EVENTS[key]);
+      events.forEach((eventName) => {
+        flicking.on(eventName, (e) => {
+          e.currentTarget = this;
+          this.$emit(eventName.replace(/([A-Z])/g, "-$1").toLowerCase(), e);
         });
       });
     },
-    checkPlugins: function () {
-      var _a, _b;
-
-      var _c = this.pluginsDiffer.update(this.plugins),
-          list = _c.list,
-          added = _c.added,
-          removed = _c.removed,
-          prevList = _c.prevList;
-
-      (_a = this.vanillaFlicking).addPlugins.apply(_a, added.map(function (index) {
-        return list[index];
-      }));
-
-      (_b = this.vanillaFlicking).removePlugins.apply(_b, removed.map(function (index) {
-        return prevList[index];
-      }));
+    checkPlugins() {
+      const { list, added, removed, prevList } = this.pluginsDiffer.update(this.plugins);
+      this.vanillaFlicking.addPlugins(...added.map((index) => list[index]));
+      this.vanillaFlicking.removePlugins(...removed.map((index) => prevList[index]));
     },
-    fillKeys: function () {
-      var vnodes = this.getSlots();
-      vnodes.forEach(function (node, idx) {
+    fillKeys() {
+      const vnodes = this.getSlots();
+      vnodes.forEach((node, idx) => {
         if (node.key == null) {
-          node.key = "$_".concat(idx);
+          node.key = `$_${idx}`;
         }
       });
     },
-    getChildren: function () {
-      var childRefs = this.$refs;
-      return Object.keys(childRefs).map(function (refKey) {
-        return childRefs[refKey];
-      });
+    getChildren() {
+      const childRefs = this.$refs;
+      return Object.keys(childRefs).map((refKey) => childRefs[refKey]);
     }
   },
   watch: {
     options: {
-      handler: function (newOptions) {
-        var flicking = this.vanillaFlicking;
-        if (!flicking) return; // Omit 'virtual', as it can't have any setter
-
-        newOptions.virtual;
-            var options = __rest(newOptions, ["virtual"]); // eslint-disable-line @typescript-eslint/no-unused-vars
-
-
-        for (var key in options) {
+      handler(newOptions) {
+        const flicking = this.vanillaFlicking;
+        if (!flicking) return;
+        const { virtual, ...options } = newOptions;
+        for (const key in options) {
           if (key in flicking && flicking[key] !== options[key]) {
             flicking[key] = options[key];
           }
@@ -660,19 +297,286 @@ var Flicking = vue.defineComponent({
     }
   }
 });
-
-var useFlickingReactiveAPI = function (flickingRef, options) {
-  return vue3.useReactive(VanillaFlicking.flickingReactiveAPIAdapter, function () {
-    var _a;
-
-    return {
-      flicking: (_a = flickingRef.value) !== null && _a !== void 0 ? _a : undefined,
-      options: options
+function keys(obj) {
+  return Object.keys(obj);
+}
+function camelize(str) {
+  return str.replace(/[\s-_]([a-z])/g, function(all, letter) {
+    return letter.toUpperCase();
+  });
+}
+function isFunction(val) {
+  return typeof val === "function";
+}
+var OBSERVERS_PATH = "__observers__";
+var COMPUTED_PATH = "__computed__";
+function __spreadArray(to, from, pack) {
+  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+function withReactiveMethods(ref, methods) {
+  var obj = {};
+  if (!methods) {
+    return obj;
+  }
+  methods.forEach(function(name) {
+    obj[name] = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      var current = ref.current || ref.value;
+      return current[name].apply(current, args);
     };
   });
+  return obj;
+}
+function defineObservers(instance) {
+  var observers = {};
+  Object.defineProperty(instance, OBSERVERS_PATH, {
+    get: function() {
+      return observers;
+    }
+  });
+  return observers;
+}
+function getObservers(instance, isComputed) {
+  var _a, _b;
+  if (!instance[OBSERVERS_PATH]) {
+    defineObservers(instance);
+  }
+  var observers = instance[OBSERVERS_PATH];
+  {
+    var computedList = (_b = (_a = instance === null || instance === void 0 ? void 0 : instance.constructor) === null || _a === void 0 ? void 0 : _a.prototype) === null || _b === void 0 ? void 0 : _b[COMPUTED_PATH];
+    if (computedList) {
+      computedList.forEach(function(name) {
+        if (!(name in observers) && name in instance) {
+          instance[name];
+        }
+      });
+    }
+  }
+  return observers;
+}
+function adaptReactive(adapter, props) {
+  var objectAdapter = isFunction(adapter) ? {
+    setup: adapter
+  } : adapter;
+  function getProps() {
+    var _a, _b, _c, _d, _e;
+    return (_e = (_c = (_a = props === null || props === void 0 ? void 0 : props()) !== null && _a !== void 0 ? _a : (_b = objectAdapter.props) === null || _b === void 0 ? void 0 : _b.call(objectAdapter)) !== null && _c !== void 0 ? _c : (_d = objectAdapter.data) === null || _d === void 0 ? void 0 : _d.call(objectAdapter)) !== null && _e !== void 0 ? _e : {};
+  }
+  var eventEmitter = new Component();
+  var mountedHooks = [];
+  var initHooks = [];
+  var destroyHooks = [];
+  var onHooks = [];
+  var instanceRef = {
+    current: null
+  };
+  var offHooksList = [];
+  var initialState = null;
+  var eventNames = [];
+  var methodNames = [];
+  var onMounted = function(callback) {
+    mountedHooks.push(callback);
+  };
+  var onInit = function(callback) {
+    initHooks.push(callback);
+  };
+  var onDestroy = function(callback) {
+    destroyHooks.push(callback);
+  };
+  var on = function(callback) {
+    onHooks.push(callback);
+  };
+  var emit = function(eventName) {
+    var params = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+      params[_i - 1] = arguments[_i];
+    }
+    eventEmitter.trigger.apply(eventEmitter, __spreadArray([eventName], params, false));
+  };
+  var setInitialState = function(state) {
+    initialState = state;
+  };
+  var setEvents = function(events) {
+    eventNames = events;
+  };
+  var setMethods = function(methods) {
+    methodNames = methods;
+  };
+  if (objectAdapter.setup) {
+    instanceRef.current = objectAdapter.setup({
+      getProps,
+      setInitialState,
+      setEvents,
+      setMethods,
+      onMounted,
+      onDestroy,
+      onInit,
+      emit,
+      on
+    }) || null;
+  }
+  if (objectAdapter.created) {
+    instanceRef.current = objectAdapter.created(getProps()) || null;
+  }
+  if (objectAdapter.events) {
+    setEvents(objectAdapter.events);
+  }
+  if (objectAdapter.state) {
+    setInitialState(objectAdapter.state);
+  }
+  if (objectAdapter.methods) {
+    setMethods(objectAdapter.methods);
+  }
+  if (objectAdapter.mounted) {
+    onMounted(objectAdapter.mounted);
+  }
+  if (objectAdapter.destroy) {
+    destroyHooks.push(objectAdapter.destroy);
+  }
+  if (objectAdapter.init) {
+    initHooks.push(objectAdapter.init);
+  }
+  if (objectAdapter.on) {
+    onHooks.push(function(instance, eventName, listener) {
+      var off = objectAdapter.on(instance, eventName, listener);
+      return function() {
+        var _a;
+        off && off();
+        (_a = objectAdapter.off) === null || _a === void 0 ? void 0 : _a.call(objectAdapter, instance, eventName, listener);
+      };
+    });
+  }
+  return {
+    events: function() {
+      return eventNames;
+    },
+    state: function() {
+      var inst = instanceRef.current;
+      if (initialState) {
+        return initialState;
+      }
+      if (inst) {
+        var observers_1 = getObservers(inst);
+        setInitialState(keys(observers_1).reduce(function(prev, cur) {
+          prev[cur] = observers_1[cur].current;
+          return prev;
+        }, {}));
+      }
+      return initialState || {};
+    },
+    instance: function() {
+      return instanceRef.current;
+    },
+    mounted: function() {
+      var props2 = getProps();
+      mountedHooks.forEach(function(hook) {
+        instanceRef.current = hook(props2, instanceRef.current) || instanceRef.current;
+      });
+    },
+    init: function() {
+      var instance = instanceRef.current;
+      var props2 = getProps();
+      offHooksList = eventNames.map(function(eventName) {
+        var listener = function() {
+          var _a;
+          var params = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+          }
+          (_a = eventEmitter).trigger.apply(_a, __spreadArray([eventName], params, false));
+        };
+        var instance2 = instanceRef.current;
+        return onHooks.map(function(hook) {
+          return hook(instance2, eventName, listener);
+        }).filter(Boolean);
+      });
+      initHooks.forEach(function(hook) {
+        hook(instance, props2);
+      });
+    },
+    destroy: function() {
+      offHooksList.forEach(function(offHooks) {
+        offHooks.forEach(function(hook) {
+          hook();
+        });
+      });
+      eventEmitter.off();
+      var instance = instanceRef.current;
+      var props2 = getProps();
+      destroyHooks.forEach(function(hook) {
+        hook(instance, props2);
+      });
+    },
+    methods: function() {
+      return withReactiveMethods(instanceRef, methodNames);
+    },
+    on: function(eventName, listener) {
+      eventEmitter.on(eventName, listener);
+    },
+    off: function(eventName, listener) {
+      eventEmitter.off(eventName, listener);
+    }
+  };
+}
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+function useReactive(reactiveAdapter, props) {
+  var adaptResult = adaptReactive(reactiveAdapter, props);
+  var reactiveState = adaptResult.state();
+  var names = Object.keys(reactiveState);
+  var refs = {};
+  for (var name in reactiveState) {
+    refs[name] = vue.ref(reactiveState[name]);
+  }
+  var methods = adaptResult.methods();
+  vue.onMounted(function() {
+    adaptResult.mounted();
+    var inst = adaptResult.instance();
+    names.forEach(function(name2) {
+      inst.subscribe(name2, function(value) {
+        refs[name2].value = value;
+      });
+    });
+    adaptResult.init();
+  });
+  vue.onUnmounted(function() {
+    adaptResult.destroy();
+  });
+  var reactiveEvents = adaptResult.events();
+  var events = reactiveEvents.reduce(function(eventResult, name2) {
+    eventResult[camelize("on ".concat(name2))] = function(callback) {
+      adaptResult.on(name2, callback);
+      vue.onUnmounted(function() {
+        adaptResult.off(name2, callback);
+      });
+    };
+    return eventResult;
+  }, {});
+  return __assign(__assign(__assign({}, refs), methods), events);
+}
+const useFlickingReactiveAPI = (flickingRef, options) => {
+  return useReactive(VanillaFlicking.flickingReactiveAPIAdapter, () => ({
+    flicking: flickingRef.value ?? void 0,
+    options
+  }));
 };
-
 Flicking.useFlickingReactiveAPI = useFlickingReactiveAPI;
-
 module.exports = Flicking;
 //# sourceMappingURL=flicking.cjs.js.map