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

package/decorators/withIntersectionObserver.js

@@ -1,27 +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; } }
-
-import { debug } from '../abstracts/Base/utils.js';
-
 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) {
@@ -30,60 +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);
+  return _temp = _class = class extends BaseClass {
+    constructor(element) {
+      super(element);
 
-    function _class(element) {
-      var _this;
-
-      _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) {
-        if (__DEV__) {
-          debug(_assertThisInitialized(_this), 'intersected', entries);
-        }
-
-        _this.$emit('intersected', entries);
+      this.$observer = new IntersectionObserver(entries => {
+        this.__debug('intersected', entries);
 
-        _this.intersected(entries);
-      }, _objectSpread(_objectSpread({}, defaultOptions), _this.$options.intersectionObserver || {}));
-
-      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('../abstracts/Base').default} Base
- * @typedef {import('../abstracts/Base').BaseOptions} BaseOptions
- * @typedef {import('../abstracts/Base').BaseComponent} BaseComponent
+ * @typedef {import('../Base').default} Base
+ * @typedef {import('../Base').BaseOptions} BaseOptions
+ * @typedef {import('../Base').BaseConstructor} BaseConstructor
  */
 /**
  * @typedef {Object} WithMountWhenInViewOptions
@@ -15,15 +15,15 @@
 /**
  * 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}
  */
-export default function withMountWhenInView<T extends typeof import("../abstracts/Base").default>(BaseClass: T, defaultOptions?: any): T;
-export type Base = import('../abstracts/Base').default;
-export type BaseOptions = import('../abstracts/Base').BaseOptions;
-export type BaseComponent = import('../abstracts/Base').BaseComponent;
+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 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('../abstracts/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,12 +26,12 @@
  * console.log(app.$options.name); // 'App'
  * ```
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  * @param {T} App
  * @param {HTMLElement} rootElement
  *
  * @return {() => Promise<InstanceType<T>>}
  *
  */
-export default function createApp<T extends typeof import("../abstracts/Base/index.js").default>(App: T, rootElement: HTMLElement): () => Promise<InstanceType<T>>;
-export type BaseComponent = import('../abstracts/Base/index.js').BaseComponent;
+export default function createApp<T extends typeof import("../Base/index.js").default>(App: T, rootElement: HTMLElement): () => Promise<InstanceType<T>>;
+export type BaseConstructor = import('../Base/index.js').BaseConstructor;

package/helpers/createApp.js

@@ -3,7 +3,7 @@ export default function createApp(App, rootElement) {
   var app;
 
   if (!isLoaded) {
-    document.addEventListener('readystatechange', function () {
+    document.addEventListener('readystatechange', () => {
       if (document.readyState === 'complete') {
         app = new App(rootElement).$mount();
         isLoaded = true;
@@ -13,20 +13,18 @@ export default function createApp(App, rootElement) {
     app = new App(rootElement).$mount();
   }
 
+  var promise = new Promise(resolve => {
+    document.addEventListener('readystatechange', () => {
+      if (document.readyState === 'complete') {
+        setTimeout(() => resolve(app), 0);
+      }
+    });
+  });
   return function useApp() {
     if (isLoaded) {
       return Promise.resolve(app);
     }
 
-    return new Promise(function (resolve) {
-      document.addEventListener('readystatechange', function () {
-        if (document.readyState === 'complete') {
-          setTimeout(function () {
-            return resolve(app);
-          }, 0);
-        }
-      });
-    });
+    return promise;
   };
-}
-//# sourceMappingURL=createApp.js.map
+}

package/helpers/importOnInteraction.d.ts

@@ -1,11 +1,11 @@
 /**
- * @typedef {import('../abstracts/Base/index.js').BaseComponent} BaseComponent
- * @typedef {import('../abstracts/Base/index.js').default} Base
+ * @typedef {import('../Base/index.js').BaseConstructor} BaseConstructor
+ * @typedef {import('../Base/index.js').default} Base
  */
 /**
  * Import a component on an interaction.
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  *
  * @param {() => Promise<T|{default:T}>} fn
  *   The import function.
@@ -18,8 +18,8 @@
  *
  * @return {Promise<T>}
  */
-export default function importOnInteraction<T extends typeof import("../abstracts/Base/index.js").default>(fn: () => Promise<T | {
+export default function importOnInteraction<T extends typeof import("../Base/index.js").default>(fn: () => Promise<T | {
     default: T;
 }>, nameOrSelectorOrElement: string | HTMLElement | HTMLElement[], events: string | string[], parent?: Base | undefined): Promise<T>;
-export type BaseComponent = import('../abstracts/Base/index.js').BaseComponent;
-export type Base = import('../abstracts/Base/index.js').default;
+export type BaseConstructor = import('../Base/index.js').BaseConstructor;
+export type Base = import('../Base/index.js').default;

package/helpers/importOnInteraction.js

@@ -3,14 +3,14 @@ export default function importOnInteraction(fn, nameOrSelectorOrElement, events,
   var normalizedEvents = typeof events === 'string' ? [events] : events;
   var ResolvedClass;
 
-  var resolver = function resolver(resolve) {
-    fn().then(function (module) {
+  var resolver = resolve => {
+    fn().then(module => {
       ResolvedClass = 'default' in module ? module.default : module;
       resolve(ResolvedClass);
     });
   };
 
-  return new Promise(function (resolve) {
+  return new Promise(resolve => {
     var elements = getTargetElements(nameOrSelectorOrElement, parent === null || parent === void 0 ? void 0 : parent.$el);
     var eventListenerOptions = {
       capture: true,
@@ -18,15 +18,14 @@ export default function importOnInteraction(fn, nameOrSelectorOrElement, events,
       once: true
     };
 
-    var handler = function handler() {
+    var handler = () => {
       resolver(resolve);
     };
 
-    elements.forEach(function (element) {
-      normalizedEvents.forEach(function (event) {
+    elements.forEach(element => {
+      normalizedEvents.forEach(event => {
         element.addEventListener(event, handler, eventListenerOptions);
       });
     });
   });
-}
-//# sourceMappingURL=importOnInteraction.js.map
+}

package/helpers/importWhenIdle.d.ts

@@ -1,11 +1,11 @@
 /**
- * @typedef {import('../abstracts/Base/index.js').BaseComponent} BaseComponent
+ * @typedef {import('../Base/index.js').BaseConstructor} BaseConstructor
  * @typedef {{ timeout?: number }} ImportWhenIdleOptions
  */
 /**
  * Import a component when user is idle.
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  *
  * @param {() => Promise<T|{default:T}>} fn
  *   The import function.
@@ -14,10 +14,10 @@
  *
  * @return {Promise<T>}
  */
-export default function importWhenIdle<T extends typeof import("../abstracts/Base/index.js").default>(fn: () => Promise<T | {
+export default function importWhenIdle<T extends typeof import("../Base/index.js").default>(fn: () => Promise<T | {
     default: T;
 }>, options?: ImportWhenIdleOptions | undefined): Promise<T>;
-export type BaseComponent = import('../abstracts/Base/index.js').BaseComponent;
+export type BaseConstructor = import('../Base/index.js').BaseConstructor;
 export type ImportWhenIdleOptions = {
     timeout?: number;
 };

package/helpers/importWhenIdle.js

@@ -1,25 +1,25 @@
 export default function importWhenIdle(fn, options) {
   var ResolvedClass;
 
-  var resolver = function resolver(resolve) {
-    fn().then(function (module) {
+  var resolver = resolve => {
+    fn().then(module => {
       ResolvedClass = 'default' in module ? module.default : module;
       resolve(ResolvedClass);
     });
   };
 
-  return new Promise(function (resolve) {
+  return new Promise(resolve => {
     var _options$timeout;
 
     var timeout = (_options$timeout = options === null || options === void 0 ? void 0 : options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : 1;
 
     if (!('requestIdleCallback' in window)) {
-      setTimeout(function () {
+      setTimeout(() => {
         resolver(resolve);
       }, timeout);
     } else {
-      window.requestIdleCallback(function () {
-        setTimeout(function () {
+      window.requestIdleCallback(() => {
+        setTimeout(() => {
           resolver(resolve);
         }, 0);
       }, {
@@ -27,5 +27,4 @@ export default function importWhenIdle(fn, options) {
       });
     }
   });
-}
-//# sourceMappingURL=importWhenIdle.js.map
+}

package/helpers/importWhenVisible.d.ts

@@ -1,11 +1,11 @@
 /**
- * @typedef {import('../abstracts/Base/index.js').default} Base
- * @typedef {import('../abstracts/Base/index.js').BaseComponent} BaseComponent
+ * @typedef {import('../Base/index.js').default} Base
+ * @typedef {import('../Base/index.js').BaseConstructor} BaseConstructor
  */
 /**
  * Import a component when it is visible.
  *
- * @template {BaseComponent} T
+ * @template {BaseConstructor} T
  *
  * @param {() => Promise<T|{default:T}>} fn
  *   The import function.
@@ -18,8 +18,8 @@
  *
  * @return {Promise<T>}
  */
-export default function importWhenVisible<T extends typeof import("../abstracts/Base/index.js").default>(fn: () => Promise<T | {
+export default function importWhenVisible<T extends typeof import("../Base/index.js").default>(fn: () => Promise<T | {
     default: T;
 }>, nameOrSelectorOrElement: string | HTMLElement | HTMLElement[], parent?: Base | undefined, observerOptions?: IntersectionObserverInit | undefined): Promise<T>;
-export type Base = import('../abstracts/Base/index.js').default;
-export type BaseComponent = import('../abstracts/Base/index.js').BaseComponent;
+export type Base = import('../Base/index.js').default;
+export type BaseConstructor = import('../Base/index.js').BaseConstructor;

package/helpers/importWhenVisible.js

@@ -3,8 +3,8 @@ export default function importWhenVisible(fn, nameOrSelectorOrElement, parent) {
   var observerOptions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
   var ResolvedClass;
 
-  var resolver = function resolver(resolve, cb) {
-    fn().then(function (module) {
+  var resolver = (resolve, cb) => {
+    fn().then(module => {
       ResolvedClass = 'default' in module ? module.default : module;
       resolve(ResolvedClass);
 
@@ -14,24 +14,17 @@ export default function importWhenVisible(fn, nameOrSelectorOrElement, parent) {
     });
   };
 
-  return new Promise(function (resolve) {
-    var observer = new IntersectionObserver(function (entries) {
-      var someEntriesAreVisible = entries.some(function (entry) {
-        return entry.isIntersecting;
-      });
+  return new Promise(resolve => {
+    var observer = new IntersectionObserver(entries => {
+      var someEntriesAreVisible = entries.some(entry => entry.isIntersecting);
 
       if (someEntriesAreVisible) {
-        setTimeout(function () {
-          resolver(resolve, function () {
-            return observer.disconnect();
-          });
+        setTimeout(() => {
+          resolver(resolve, () => observer.disconnect());
         }, 0);
       }
     }, observerOptions);
     var elements = getTargetElements(nameOrSelectorOrElement, parent === null || parent === void 0 ? void 0 : parent.$el);
-    elements.forEach(function (element) {
-      return observer.observe(element);
-    });
+    elements.forEach(element => observer.observe(element));
   });
-}
-//# sourceMappingURL=importWhenVisible.js.map
+}

package/helpers/index.d.ts

@@ -1,7 +1,5 @@
 import createApp from "./createApp.js";
-import createBase from "./createBase.js";
-import defineComponent from "./defineComponent.js";
 import importOnInteraction from "./importOnInteraction.js";
 import importWhenIdle from "./importWhenIdle.js";
 import importWhenVisible from "./importWhenVisible.js";
-export { createApp, createBase, defineComponent, importOnInteraction, importWhenIdle, importWhenVisible };
+export { createApp, importOnInteraction, importWhenIdle, importWhenVisible };

package/helpers/index.js

@@ -1,8 +1,5 @@
 import createApp from './createApp.js';
-import createBase from './createBase.js';
-import defineComponent from './defineComponent.js';
 import importOnInteraction from './importOnInteraction.js';
 import importWhenIdle from './importWhenIdle.js';
 import importWhenVisible from './importWhenVisible.js';
-export { createApp, createBase, defineComponent, importOnInteraction, importWhenIdle, importWhenVisible };
-//# sourceMappingURL=index.js.map
+export { createApp, importOnInteraction, importWhenIdle, importWhenVisible };

package/helpers/utils.js

@@ -1,4 +1,4 @@
-import { getComponentElements } from '../abstracts/Base/utils.js';
+import { getComponentElements } from '../Base/utils.js';
 export function getTargetElements(nameOrSelectorOrElement, context) {
   if (typeof nameOrSelectorOrElement === 'string') {
     return getComponentElements(nameOrSelectorOrElement, context);
@@ -9,5 +9,4 @@ export function getTargetElements(nameOrSelectorOrElement, context) {
   }
 
   return nameOrSelectorOrElement;
-}
-//# sourceMappingURL=utils.js.map
+}

package/index.d.ts

@@ -1,5 +1,19 @@
-export default Base;
-import Base from "./abstracts/Base/index.js";
-import createBase from "./helpers/createBase.js";
-import defineComponent from "./helpers/defineComponent.js";
-export { Base, createBase, defineComponent };
+import Base from "./Base/index.js";
+import { createApp } from "./helpers/index.js";
+import { importOnInteraction } from "./helpers/index.js";
+import { importWhenIdle } from "./helpers/index.js";
+import { importWhenVisible } from "./helpers/index.js";
+import { useDrag } from "./services/index.js";
+import { useKey } from "./services/index.js";
+import { useLoad } from "./services/index.js";
+import { usePointer } from "./services/index.js";
+import { useRaf } from "./services/index.js";
+import { useResize } from "./services/index.js";
+import { useScroll } from "./services/index.js";
+import { withBreakpointManager } from "./decorators/index.js";
+import { withBreakpointObserver } from "./decorators/index.js";
+import { withDrag } from "./decorators/index.js";
+import { withExtraConfig } from "./decorators/index.js";
+import { withIntersectionObserver } from "./decorators/index.js";
+import { withMountWhenInView } from "./decorators/index.js";
+export { Base, createApp, importOnInteraction, importWhenIdle, importWhenVisible, useDrag, useKey, useLoad, usePointer, useRaf, useResize, useScroll, withBreakpointManager, withBreakpointObserver, withDrag, withExtraConfig, withIntersectionObserver, withMountWhenInView };

package/index.js

@@ -1,6 +1,5 @@
-import Base from './abstracts/Base/index.js';
-import defineComponent from './helpers/defineComponent.js';
-import createBase from './helpers/createBase.js';
-export { Base, createBase, defineComponent };
-export default Base;
-//# sourceMappingURL=index.js.map
+import Base from './Base/index.js';
+import { withDrag, withBreakpointManager, withBreakpointObserver, withExtraConfig, withIntersectionObserver, withMountWhenInView } from './decorators/index.js';
+import { createApp, importOnInteraction, importWhenIdle, importWhenVisible } from './helpers/index.js';
+import { useDrag, useKey, useLoad, usePointer, useRaf, useResize, useScroll } from './services/index.js';
+export { Base, createApp, importOnInteraction, importWhenIdle, importWhenVisible, useDrag, useKey, useLoad, usePointer, useRaf, useResize, useScroll, withBreakpointManager, withBreakpointObserver, withDrag, withExtraConfig, withIntersectionObserver, withMountWhenInView };