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

package/decorators/withBreakpointManager.js

@@ -1,52 +1,32 @@
-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 _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-
-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(breakpoints) {
-  var _useResize$props = useResize().props(),
-      breakpoint = _useResize$props.breakpoint;
-
-  breakpoints.forEach(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-        breakpointKeys = _ref2[0],
-        instance = _ref2[1];
-
-    if (breakpointKeys.includes(breakpoint)) {
-      instance.$mount();
-    } else {
+  var {
+    breakpoint
+  } = useResize().props();
+  breakpoints.forEach(_ref => {
+    var [breakpointKeys, instance] = _ref;
+
+    if (breakpointKeys.includes(breakpoint) && !instance.$isMounted) {
+      setTimeout(() => instance.$mount(), 0);
+    } else if (!breakpointKeys.includes(breakpoint) && instance.$isMounted) {
       instance.$destroy();
     }
   });
 }
 
 function mountComponents(instance, breakpoints) {
-  return breakpoints.map(function (_ref3) {
-    var _ref4 = _slicedToArray(_ref3, 2),
-        bk = _ref4[0],
-        ComponentClass = _ref4[1];
-
+  return breakpoints.map(_ref2 => {
+    var [bk, ComponentClass] = _ref2;
     var child = new ComponentClass(instance.$el);
     Object.defineProperty(child, '$parent', {
-      get: function get() {
-        return instance;
-      }
+      get: () => instance.$parent
     });
     return [bk, child];
   });
 }
 
-var instances = {};
+var instances = new WeakMap();
 export default function withBreakpointManager(BaseClass, breakpoints) {
   if (!Array.isArray(breakpoints)) {
     throw new Error('[withBreakpointManager] The `breakpoints` parameter must be an array.');
@@ -56,64 +36,46 @@ export default function withBreakpointManager(BaseClass, breakpoints) {
     throw new Error('[withBreakpointManager] You must define at least 2 breakpoints.');
   }
 
-  var _useResize = useResize(),
-      add = _useResize.add,
-      props = _useResize.props;
+  var {
+    add,
+    props
+  } = useResize();
 
   if (!props().breakpoint) {
     throw new Error("The `BreakpointManager` class requires breakpoints to be defined.");
   }
 
-  return function (_BaseClass) {
-    _inherits(_class, _BaseClass);
-
-    var _super = _createSuper(_class);
+  return class extends BaseClass {
+    constructor(element) {
+      super(element);
 
-    function _class(element) {
-      var _this;
-
-      _classCallCheck(this, _class);
-
-      _this = _super.call(this, element);
-
-      if (!instances[_this.$id]) {
-        instances[_this.$id] = mountComponents(_assertThisInitialized(_this), breakpoints);
+      if (!instances.has(this)) {
+        instances.set(this, mountComponents(this, breakpoints));
       }
 
-      testBreakpoints(instances[_this.$id]);
-      add("BreakpointManager-".concat(_this.$id), function () {
-        testBreakpoints(instances[_this.$id]);
+      add("BreakpointManager-".concat(this.$id), () => {
+        testBreakpoints(instances.get(this));
       });
-      return _possibleConstructorReturn(_this, _assertThisInitialized(_this));
+      this.instances = instances.get(this);
+      return this;
     }
 
-    _createClass(_class, [{
-      key: "$mount",
-      value: function $mount() {
-        if (!instances[this.$id]) {
-          instances[this.$id] = mountComponents(this, breakpoints);
-        }
+    $mount() {
+      super.$mount();
+      testBreakpoints(instances.get(this));
+      return this;
+    }
 
-        testBreakpoints(instances[this.$id]);
-        return _get(_getPrototypeOf(_class.prototype), "$mount", this).call(this);
+    $destroy() {
+      if (Array.isArray(instances.get(this))) {
+        instances.get(this).forEach(_ref3 => {
+          var [, instance] = _ref3;
+          instance.$destroy();
+        });
       }
-    }, {
-      key: "$destroy",
-      value: function $destroy() {
-        if (Array.isArray(instances[this.$id])) {
-          instances[this.$id].forEach(function (_ref5) {
-            var _ref6 = _slicedToArray(_ref5, 2),
-                instance = _ref6[1];
 
-            instance.$destroy();
-          });
-        }
-
-        return _get(_getPrototypeOf(_class.prototype), "$destroy", this).call(this);
-      }
-    }]);
+      return super.$destroy();
+    }
 
-    return _class;
-  }(BaseClass);
-}
-//# sourceMappingURL=withBreakpointManager.js.map
+  };
+}

package/decorators/withBreakpointObserver.d.ts

@@ -1,13 +1,13 @@
 /**
  * BreakpointObserver class.
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  * @param {T} BaseClass The Base class to extend from.
  * @return {T}
  */
-export default function withBreakpointObserver<T extends typeof import("../abstracts/Base").default>(BaseClass: T): T;
-export type Base = import('../abstracts/Base').default;
-export type BaseComponent = import('../abstracts/Base').BaseComponent;
+export default function withBreakpointObserver<T extends typeof import("../Base").default>(BaseClass: T): T;
+export type Base = import('../Base').default;
+export type BaseConstructor = import('../Base').BaseConstructor;
 export type WithBreakpointObserverOptions = {
     activeBreakpoints?: string;
     inactiveBreakpoints?: string;

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('../abstracts/Base').default} Base
- * @typedef {import('../abstracts/Base').BaseComponent} BaseComponent
+ * @typedef {import('../Base').default} Base
+ * @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("../abstracts/Base").default>(BaseClass: T, options?: DragDecoratorOptions): T;
-export type Base = import('../abstracts/Base').default;
-export type BaseComponent = import('../abstracts/Base').BaseComponent;
+export default function withDrag<T extends typeof import("../Base").default>(BaseClass: T, options?: DragDecoratorOptions): T;
+export type Base = import('../Base').default;
+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,18 +1,18 @@
 /**
  * @typedef {import('deepmerge').Options} DeepmergeOptions
- * @typedef {import('../abstracts/Base').BaseConfig} BaseConfig
- * @typedef {import('../abstracts/Base').BaseComponent} BaseComponent
+ * @typedef {import('../Base').BaseConfig} BaseConfig
+ * @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}
  * @return {T}
  */
-export default function withExtraConfig<T extends typeof import("../abstracts/Base").default>(BaseClass: T, config: Partial<BaseConfig>, options?: DeepmergeOptions): T;
+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('../abstracts/Base').BaseConfig;
-export type BaseComponent = import('../abstracts/Base').BaseComponent;
+export type BaseConfig = import('../Base').BaseConfig;
+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,18 +1,18 @@
 /**
  * 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 }}}
  */
-export default function withIntersectionObserver<T extends typeof import("../abstracts/Base").default>(BaseClass: T, defaultOptions?: any): T & {
+export default function withIntersectionObserver<T extends typeof import("../Base").default>(BaseClass: T, defaultOptions?: any): T & {
     new: (element: HTMLElement) => {
         $observer: IntersectionObserver;
     };
 };
-export type Base = import('../abstracts/Base').default;
-export type BaseComponent = import('../abstracts/Base').BaseComponent;
+export type Base = import('../Base').default;
+export type BaseConstructor = import('../Base').BaseConstructor;
 export type WithIntersectionObserverOptions = {
     intersectionObserver: any;
 };