@studiometa/js-toolkit 2.0.0-alpha.1 → 2.0.0-alpha.10

package/decorators/withBreakpointObserver.js

@@ -1,28 +1,17 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _get from "@babel/runtime/helpers/get";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 import useResize from '../services/resize.js';
 
 function testBreakpoints(instance) {
   var breakpoint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : useResize().props().breakpoint;
-  var _instance$$options = instance.$options,
-      activeBreakpoints = _instance$$options.activeBreakpoints,
-      inactiveBreakpoints = _instance$$options.inactiveBreakpoints;
+  var {
+    activeBreakpoints,
+    inactiveBreakpoints
+  } = instance.$options;
   var isInActiveBreakpoint = activeBreakpoints && activeBreakpoints.split(' ').includes(breakpoint);
   var isInInactiveBreakpoint = inactiveBreakpoints && inactiveBreakpoints.split(' ').includes(breakpoint);
 
@@ -34,17 +23,19 @@ function testBreakpoints(instance) {
 }
 
 function hasBreakpointConfiguration(instance) {
-  var _instance$$options2 = instance.$options,
-      activeBreakpoints = _instance$$options2.activeBreakpoints,
-      inactiveBreakpoints = _instance$$options2.inactiveBreakpoints;
+  var {
+    activeBreakpoints,
+    inactiveBreakpoints
+  } = instance.$options;
   return Boolean(activeBreakpoints || inactiveBreakpoints);
 }
 
 function testConflictingBreakpointConfiguration(instance) {
-  var _instance$$options3 = instance.$options,
-      activeBreakpoints = _instance$$options3.activeBreakpoints,
-      inactiveBreakpoints = _instance$$options3.inactiveBreakpoints,
-      name = _instance$$options3.name;
+  var {
+    activeBreakpoints,
+    inactiveBreakpoints,
+    name
+  } = instance.$options;
 
   if (activeBreakpoints && inactiveBreakpoints) {
     throw new Error("[".concat(name, "] Incorrect configuration: the `activeBreakpoints` and `inactiveBreakpoints` are not compatible."));
@@ -53,22 +44,22 @@ function testConflictingBreakpointConfiguration(instance) {
 
 function addToResize(key, instance) {
   testConflictingBreakpointConfiguration(instance);
-
-  var _useResize = useResize(),
-      add = _useResize.add,
-      has = _useResize.has;
+  var {
+    add,
+    has
+  } = useResize();
 
   if (!has(key)) {
     add(key, function onResize(_ref) {
-      var breakpoint = _ref.breakpoint;
+      var {
+        breakpoint
+      } = _ref;
       var action = testBreakpoints(instance, breakpoint);
 
       if (action === '$destroy' && instance.$isMounted) {
         instance[action]();
       } else if (action === '$mount' && !instance.$isMounted) {
-        setTimeout(function () {
-          return instance[action]();
-        }, 0);
+        setTimeout(() => instance[action](), 0);
       }
     });
   }
@@ -77,80 +68,66 @@ function addToResize(key, instance) {
 export default function withBreakpointObserver(BaseClass) {
   var _class, _temp, _BaseClass$config$nam, _BaseClass$config, _BaseClass$config2;
 
-  return _temp = _class = function (_BaseClass) {
-    _inherits(_class, _BaseClass);
-
-    var _super = _createSuper(_class);
-
-    function _class(element) {
-      var _this;
-
-      _classCallCheck(this, _class);
-
-      _this = _super.call(this, element);
-
-      var _useResize2 = useResize(),
-          remove = _useResize2.remove,
-          props = _useResize2.props;
-
-      var name = _this.$options.name;
+  return _temp = _class = class extends BaseClass {
+    constructor(element) {
+      super(element);
+      var {
+        remove,
+        props
+      } = useResize();
+      var {
+        name
+      } = this.$options;
 
       if (!props().breakpoint) {
         throw new Error("[".concat(name, "] The `BreakpointObserver` class requires breakpoints to be defined."));
       }
 
-      var key = "BreakpointObserver-".concat(_this.$id);
-      var mutationObserver = new MutationObserver(function (_ref2) {
-        var _ref3 = _slicedToArray(_ref2, 1),
-            mutation = _ref3[0];
+      var key = "BreakpointObserver-".concat(this.$id);
+      var mutationObserver = new MutationObserver(_ref2 => {
+        var [mutation] = _ref2;
 
         if (mutation.type === 'attributes' && (mutation.attributeName === 'data-options' || mutation.attributeName.startsWith('data-option-'))) {
-          if (!hasBreakpointConfiguration(_assertThisInitialized(_this))) {
-            _this.$mount();
-
+          if (!hasBreakpointConfiguration(this)) {
+            this.$mount();
             remove(key);
             return;
           }
 
-          addToResize(key, _assertThisInitialized(_this));
+          addToResize(key, this);
         }
       });
-      mutationObserver.observe(_this.$el, {
+      mutationObserver.observe(this.$el, {
         attributes: true
       });
 
-      if (!hasBreakpointConfiguration(_assertThisInitialized(_this))) {
-        return _possibleConstructorReturn(_this, _assertThisInitialized(_this));
+      if (!hasBreakpointConfiguration(this)) {
+        return this;
       }
 
-      addToResize(key, _assertThisInitialized(_this));
-      return _possibleConstructorReturn(_this, _assertThisInitialized(_this));
+      addToResize(key, this);
+      return this;
     }
 
-    _createClass(_class, [{
-      key: "$mount",
-      value: function $mount() {
-        if (!hasBreakpointConfiguration(this)) {
-          return _get(_getPrototypeOf(_class.prototype), "$mount", this).call(this);
-        }
-
-        var action = testBreakpoints(this);
+    $mount() {
+      if (!hasBreakpointConfiguration(this)) {
+        return super.$mount();
+      }
 
-        if (action === '$mount') {
-          return _get(_getPrototypeOf(_class.prototype), "$mount", this).call(this);
-        }
+      var action = testBreakpoints(this);
 
-        return this;
+      if (action === '$mount') {
+        return super.$mount();
       }
-    }]);
 
-    return _class;
-  }(BaseClass), _defineProperty(_class, "config", _objectSpread(_objectSpread({}, BaseClass.config || {}), {}, {
+      return this;
+    }
+
+  }, _defineProperty(_class, "config", _objectSpread(_objectSpread({}, BaseClass.config || {}), {}, {
     name: "".concat((_BaseClass$config$nam = BaseClass === null || BaseClass === void 0 ? void 0 : (_BaseClass$config = BaseClass.config) === null || _BaseClass$config === void 0 ? void 0 : _BaseClass$config.name) !== null && _BaseClass$config$nam !== void 0 ? _BaseClass$config$nam : '', "WithBreakpointObserver"),
     options: _objectSpread(_objectSpread({}, (BaseClass === null || BaseClass === void 0 ? void 0 : (_BaseClass$config2 = BaseClass.config) === null || _BaseClass$config2 === void 0 ? void 0 : _BaseClass$config2.options) || {}), {}, {
       activeBreakpoints: String,
       inactiveBreakpoints: String
     })
   })), _temp;
-}
-//# sourceMappingURL=withBreakpointObserver.js.map
+}

package/decorators/withDrag.d.ts

@@ -1,6 +1,6 @@
 /**
  * @typedef {import('../Base').default} Base
- * @typedef {import('../Base').BaseComponent} BaseComponent
+ * @typedef {import('../Base').BaseConstructor} BaseConstructor
  * @typedef {import('../services/drag').DragServiceOptions} DragServiceOptions
  */
 /**
@@ -9,14 +9,14 @@
 /**
  * Add dragging capabilities to a component.
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  * @param {T} BaseClass
  * @param {DragDecoratorOptions} options
  * @return {T}
  */
 export default function withDrag<T extends typeof import("../Base").default>(BaseClass: T, options?: DragDecoratorOptions): T;
 export type Base = import('../Base').default;
-export type BaseComponent = import('../Base').BaseComponent;
+export type BaseConstructor = import('../Base').BaseConstructor;
 export type DragServiceOptions = import('../services/drag').DragServiceOptions;
 export type DragDecoratorOptions = import("../services/drag.js").DragServiceOptions & {
     target: (this: Base) => HTMLElement;

package/decorators/withDrag.js

@@ -1,55 +1,31 @@
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 var _excluded = ["target"];
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 import useDrag from '../services/drag.js';
 export default function withDrag(BaseClass) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-    target: function target() {
+    target() {
       return this.$el;
     }
-  };
-  return function (_BaseClass) {
-    _inherits(_class, _BaseClass);
-
-    var _super = _createSuper(_class);
-
-    function _class(el) {
-      var _this;
-
-      _classCallCheck(this, _class);
-
-      _this = _super.call(this, el);
 
-      _this.$on('mounted', function () {
-        var target = options.target,
+  };
+  return class extends BaseClass {
+    constructor(el) {
+      super(el);
+      this.$on('mounted', () => {
+        var {
+          target
+        } = options,
             otherOptions = _objectWithoutProperties(options, _excluded);
 
-        var boundUseDrag = useDrag.bind(undefined, target.call(_assertThisInitialized(_this)), otherOptions);
-
-        _this.$services.register('dragged', boundUseDrag);
-
-        _this.$services.enable('dragged');
+        var boundUseDrag = useDrag.bind(undefined, target.call(this), otherOptions);
+        this.$services.register('dragged', boundUseDrag);
+        this.$services.enable('dragged');
       });
-
-      _this.$on('destroyed', function () {
-        _this.$services.disable('dragged');
-
-        _this.$services.unregister('dragged');
+      this.$on('destroyed', () => {
+        this.$services.disable('dragged');
+        this.$services.unregister('dragged');
       });
-
-      return _this;
     }
 
-    return _class;
-  }(BaseClass);
-}
-//# sourceMappingURL=withDrag.js.map
+  };
+}

package/decorators/withExtraConfig.d.ts

@@ -1,12 +1,12 @@
 /**
  * @typedef {import('deepmerge').Options} DeepmergeOptions
  * @typedef {import('../Base').BaseConfig} BaseConfig
- * @typedef {import('../Base').BaseComponent} BaseComponent
+ * @typedef {import('../Base').BaseConstructor} BaseConstructor
  */
 /**
  * Extends the configuration of an existing class.
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  * @param {T} BaseClass The Base class to extend.
  * @param {Partial<BaseConfig>} config Extra configuration to merge.
  * @param {DeepmergeOptions} options Options for the `deepmerge` function. {@link https://github.com/TehShrike/deepmerge#options}
@@ -15,4 +15,4 @@
 export default function withExtraConfig<T extends typeof import("../Base").default>(BaseClass: T, config: Partial<BaseConfig>, options?: DeepmergeOptions): T;
 export type DeepmergeOptions = import('deepmerge').Options;
 export type BaseConfig = import('../Base').BaseConfig;
-export type BaseComponent = import('../Base').BaseComponent;
+export type BaseConstructor = import('../Base').BaseConstructor;

package/decorators/withExtraConfig.js

@@ -1,13 +1,4 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 import merge from 'deepmerge';
 export default function withExtraConfig(BaseClass, config) {
   var _class, _temp;
@@ -19,18 +10,5 @@ export default function withExtraConfig(BaseClass, config) {
     newConfig.name = "".concat(BaseClass.config.name, "WithExtraConfig");
   }
 
-  return _temp = _class = function (_BaseClass) {
-    _inherits(_class, _BaseClass);
-
-    var _super = _createSuper(_class);
-
-    function _class() {
-      _classCallCheck(this, _class);
-
-      return _super.apply(this, arguments);
-    }
-
-    return _class;
-  }(BaseClass), _defineProperty(_class, "config", newConfig), _temp;
-}
-//# sourceMappingURL=withExtraConfig.js.map
+  return _temp = _class = class extends BaseClass {}, _defineProperty(_class, "config", newConfig), _temp;
+}

package/decorators/withIntersectionObserver.d.ts

@@ -1,7 +1,7 @@
 /**
  * IntersectionObserver decoration.
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  * @param {T} BaseClass The Base class to extend.
  * @param {Object} [defaultOptions] The options for the IntersectionObserver instance.
  * @return {T & { new: (element:HTMLElement) => { $observer: IntersectionObserver }}}
@@ -12,7 +12,7 @@ export default function withIntersectionObserver<T extends typeof import("../Bas
     };
 };
 export type Base = import('../Base').default;
-export type BaseComponent = import('../Base').BaseComponent;
+export type BaseConstructor = import('../Base').BaseConstructor;
 export type WithIntersectionObserverOptions = {
     intersectionObserver: any;
 };

package/decorators/withIntersectionObserver.js

@@ -1,25 +1,11 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _get from "@babel/runtime/helpers/get";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 function createArrayOfNumber(length) {
-  return _toConsumableArray(new Array(length + 1)).map(function (val, index) {
-    return index / length;
-  });
+  return [...new Array(length + 1)].map((val, index) => index / length);
 }
 
 export default function withIntersectionObserver(BaseClass) {
@@ -28,58 +14,33 @@ export default function withIntersectionObserver(BaseClass) {
   var defaultOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
     threshold: createArrayOfNumber(100)
   };
-  return _temp = _class = function (_BaseClass) {
-    _inherits(_class, _BaseClass);
-
-    var _super = _createSuper(_class);
-
-    function _class(element) {
-      var _this;
+  return _temp = _class = class extends BaseClass {
+    constructor(element) {
+      super(element);
 
-      _classCallCheck(this, _class);
-
-      _this = _super.call(this, element);
-
-      if (!_this.intersected || typeof _this.intersected !== 'function') {
+      if (!this.intersected || typeof this.intersected !== 'function') {
         throw new Error('[withIntersectionObserver] The `intersected` method must be defined.');
       }
 
-      _this.$observer = new IntersectionObserver(function (entries) {
-        _this.__debug('intersected', entries);
-
-        _this.$emit('intersected', entries);
-
-        _this.intersected(entries);
-      }, _objectSpread(_objectSpread({}, defaultOptions), _this.$options.intersectionObserver || {}));
+      this.$observer = new IntersectionObserver(entries => {
+        this.__debug('intersected', entries);
 
-      if (_this.$isMounted) {
-        _this.$observer.observe(_this.$el);
-      }
-
-      _this.$on('mounted', function () {
-        _this.$observer.observe(_this.$el);
+        this.$emit('intersected', entries);
+        this.intersected(entries);
+      }, _objectSpread(_objectSpread({}, defaultOptions), this.$options.intersectionObserver || {}));
+      this.$on('mounted', () => {
+        this.$observer.observe(this.$el);
       });
-
-      _this.$on('destroyed', function () {
-        _this.$observer.unobserve(_this.$el);
+      this.$on('destroyed', () => {
+        this.$observer.unobserve(this.$el);
       });
-
-      return _possibleConstructorReturn(_this, _assertThisInitialized(_this));
+      return this;
     }
 
-    _createClass(_class, [{
-      key: "__excludeFromAutoBind",
-      get: function get() {
-        return [].concat(_toConsumableArray(_get(_getPrototypeOf(_class.prototype), "__excludeFromAutoBind", this) || []), ['intersected']);
-      }
-    }]);
-
-    return _class;
-  }(BaseClass), _defineProperty(_class, "config", _objectSpread(_objectSpread({}, BaseClass.config || {}), {}, {
+  }, _defineProperty(_class, "config", _objectSpread(_objectSpread({}, BaseClass.config || {}), {}, {
     name: "".concat((_BaseClass$config$nam = BaseClass === null || BaseClass === void 0 ? void 0 : (_BaseClass$config = BaseClass.config) === null || _BaseClass$config === void 0 ? void 0 : _BaseClass$config.name) !== null && _BaseClass$config$nam !== void 0 ? _BaseClass$config$nam : '', "WithIntersectionObserver"),
     options: _objectSpread(_objectSpread({}, (BaseClass === null || BaseClass === void 0 ? void 0 : (_BaseClass$config2 = BaseClass.config) === null || _BaseClass$config2 === void 0 ? void 0 : _BaseClass$config2.options) || {}), {}, {
       intersectionObserver: Object
     })
   })), _temp;
-}
-//# sourceMappingURL=withIntersectionObserver.js.map
+}

package/decorators/withMountWhenInView.d.ts

@@ -1,7 +1,7 @@
 /**
  * @typedef {import('../Base').default} Base
  * @typedef {import('../Base').BaseOptions} BaseOptions
- * @typedef {import('../Base').BaseComponent} BaseComponent
+ * @typedef {import('../Base').BaseConstructor} BaseConstructor
  */
 /**
  * @typedef {Object} WithMountWhenInViewOptions
@@ -15,7 +15,7 @@
 /**
  * IntersectionObserver decoration.
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  * @param {T} BaseClass The Base class to extend.
  * @param {Object} [defaultOptions] The options for the IntersectionObserver instance.
  * @return {T}
@@ -23,7 +23,7 @@
 export default function withMountWhenInView<T extends typeof import("../Base").default>(BaseClass: T, defaultOptions?: any): T;
 export type Base = import('../Base').default;
 export type BaseOptions = import('../Base').BaseOptions;
-export type BaseComponent = import('../Base').BaseComponent;
+export type BaseConstructor = import('../Base').BaseConstructor;
 export type WithMountWhenInViewOptions = {
     intersectionObserver: any;
 };

package/decorators/withMountWhenInView.js

@@ -1,10 +1,3 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _get from "@babel/runtime/helpers/get";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _classPrivateFieldGet from "@babel/runtime/helpers/classPrivateFieldGet";
 import _classPrivateFieldSet from "@babel/runtime/helpers/classPrivateFieldSet";
@@ -13,78 +6,57 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 export default function withMountWhenInView(BaseClass) {
   var _class, _isVisible, _observer, _temp, _BaseClass$config$nam, _BaseClass$config, _BaseClass$config2;
 
   var defaultOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
     threshold: [0, 1]
   };
-  return _temp = (_isVisible = new WeakMap(), _observer = new WeakMap(), _class = function (_BaseClass) {
-    _inherits(_class, _BaseClass);
-
-    var _super = _createSuper(_class);
-
-    function _class(element) {
-      var _this;
-
-      _classCallCheck(this, _class);
-
-      _this = _super.call(this, element);
+  return _temp = (_isVisible = new WeakMap(), _observer = new WeakMap(), _class = class extends BaseClass {
+    constructor(element) {
+      super(element);
 
-      _isVisible.set(_assertThisInitialized(_this), {
+      _isVisible.set(this, {
         writable: true,
         value: false
       });
 
-      _observer.set(_assertThisInitialized(_this), {
+      _observer.set(this, {
         writable: true,
         value: void 0
       });
 
-      _classPrivateFieldSet(_assertThisInitialized(_this), _observer, new IntersectionObserver(function (entries) {
-        var isVisible = entries.reduce(function (acc, entry) {
-          return acc || entry.isIntersecting;
-        }, false);
+      _classPrivateFieldSet(this, _observer, new IntersectionObserver(entries => {
+        var isVisible = entries.reduce((acc, entry) => acc || entry.isIntersecting, false);
 
-        if (_classPrivateFieldGet(_assertThisInitialized(_this), _isVisible) !== isVisible) {
-          _classPrivateFieldSet(_assertThisInitialized(_this), _isVisible, isVisible);
+        if (_classPrivateFieldGet(this, _isVisible) !== isVisible) {
+          _classPrivateFieldSet(this, _isVisible, isVisible);
 
           var method = isVisible ? '$mount' : '$destroy';
-
-          _this[method]();
+          this[method]();
         }
-      }, _objectSpread(_objectSpread({}, defaultOptions), _this.$options.intersectionObserver)));
+      }, _objectSpread(_objectSpread({}, defaultOptions), this.$options.intersectionObserver)));
 
-      _classPrivateFieldGet(_assertThisInitialized(_this), _observer).observe(_this.$el);
+      _classPrivateFieldGet(this, _observer).observe(this.$el);
 
-      _this.$on('terminated', function () {
-        _classPrivateFieldGet(_assertThisInitialized(_this), _observer).disconnect();
+      this.$on('terminated', () => {
+        _classPrivateFieldGet(this, _observer).disconnect();
       });
-
-      return _possibleConstructorReturn(_this, _assertThisInitialized(_this));
+      return this;
     }
 
-    _createClass(_class, [{
-      key: "$mount",
-      value: function $mount() {
-        if (_classPrivateFieldGet(this, _isVisible)) {
-          _get(_getPrototypeOf(_class.prototype), "$mount", this).call(this);
-        }
-
-        return this;
+    $mount() {
+      if (_classPrivateFieldGet(this, _isVisible)) {
+        super.$mount();
       }
-    }]);
 
-    return _class;
-  }(BaseClass)), _defineProperty(_class, "config", _objectSpread(_objectSpread({}, BaseClass.config || {}), {}, {
+      return this;
+    }
+
+  }), _defineProperty(_class, "config", _objectSpread(_objectSpread({}, BaseClass.config || {}), {}, {
     name: "".concat((_BaseClass$config$nam = BaseClass === null || BaseClass === void 0 ? void 0 : (_BaseClass$config = BaseClass.config) === null || _BaseClass$config === void 0 ? void 0 : _BaseClass$config.name) !== null && _BaseClass$config$nam !== void 0 ? _BaseClass$config$nam : '', "WithMountWhenInView"),
     options: _objectSpread(_objectSpread({}, (BaseClass === null || BaseClass === void 0 ? void 0 : (_BaseClass$config2 = BaseClass.config) === null || _BaseClass$config2 === void 0 ? void 0 : _BaseClass$config2.options) || {}), {}, {
       intersectionObserver: Object
     })
   })), _temp;
-}
-//# sourceMappingURL=withMountWhenInView.js.map
+}

package/helpers/createApp.d.ts

@@ -1,5 +1,5 @@
 /**
- * @typedef {import('../Base/index.js').BaseComponent} BaseComponent
+ * @typedef {import('../Base/index.js').BaseConstructor} BaseConstructor
  */
 /**
  * Instantiate and mount the given component on the given root element when the page has been loaded
@@ -26,7 +26,7 @@
  * console.log(app.$options.name); // 'App'
  * ```
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  * @param {T} App
  * @param {HTMLElement} rootElement
  *
@@ -34,4 +34,4 @@
  *
  */
 export default function createApp<T extends typeof import("../Base/index.js").default>(App: T, rootElement: HTMLElement): () => Promise<InstanceType<T>>;
-export type BaseComponent = import('../Base/index.js').BaseComponent;
+export type BaseConstructor = import('../Base/index.js').BaseConstructor;