@studiometa/js-toolkit 2.0.0-beta.7 → 2.0.0-rc.1

package/Base/managers/ServicesManager.cjs

@@ -0,0 +1,131 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// packages/js-toolkit/Base/managers/ServicesManager.js
+var ServicesManager_exports = {};
+__export(ServicesManager_exports, {
+  default: () => ServicesManager
+});
+module.exports = __toCommonJS(ServicesManager_exports);
+var import_pointer = __toESM(require("../../services/pointer.cjs"), 1);
+var import_raf = __toESM(require("../../services/raf.cjs"), 1);
+var import_resize = __toESM(require("../../services/resize.cjs"), 1);
+var import_scroll = __toESM(require("../../services/scroll.cjs"), 1);
+var import_key = __toESM(require("../../services/key.cjs"), 1);
+var import_load = __toESM(require("../../services/load.cjs"), 1);
+var import_utils = require("../utils.cjs");
+var SERVICES_MAP = {
+  scrolled: import_scroll.default,
+  resized: import_resize.default,
+  ticked: import_raf.default,
+  moved: import_pointer.default,
+  keyed: import_key.default,
+  loaded: import_load.default
+};
+var SERVICE_NAMES = Object.keys(SERVICES_MAP);
+var ServicesManager = class {
+  constructor(instance) {
+    __publicField(this, "__base");
+    __publicField(this, "__customServices", {});
+    Object.defineProperties(this, {
+      __base: {
+        enumerable: false,
+        writable: false,
+        value: instance
+      }
+    });
+  }
+  get __services() {
+    return {
+      ...this.__customServices,
+      ...SERVICES_MAP
+    };
+  }
+  has(service) {
+    if (!(((0, import_utils.hasMethod)(this.__base, service) || this.__base.__hasEvent(service)) && this.__services[service])) {
+      return false;
+    }
+    const { has } = this.__services[service]();
+    return has(this.__base.$id);
+  }
+  enable(service) {
+    if (this.has(service)) {
+      return this.disable.bind(this, service);
+    }
+    if (!((0, import_utils.hasMethod)(this.__base, service) || this.__base.__hasEvent(service)) || !this.__services[service]) {
+      return function noop() {
+      };
+    }
+    const { add } = this.__services[service]();
+    const self = this;
+    function serviceHandler(...args) {
+      self.__base.__callMethod(service, ...args);
+    }
+    add(this.__base.$id, serviceHandler);
+    return this.disable.bind(this, service);
+  }
+  enableAll() {
+    return Object.keys(this.__services).map((serviceName) => this.enable(serviceName));
+  }
+  disableAll() {
+    Object.keys(this.__services).forEach((serviceName) => {
+      this.disable(serviceName);
+    });
+  }
+  disable(service) {
+    if (!this.__services[service]) {
+      return;
+    }
+    const { remove } = this.__services[service]();
+    remove(this.__base.$id);
+  }
+  toggle(service, force) {
+    if (typeof force !== "undefined") {
+      if (force && !this.has(service)) {
+        this.enable(service);
+      }
+      if (!force && this.has(service)) {
+        this.disable(service);
+      }
+    } else if (this.has(service)) {
+      this.disable(service);
+    } else {
+      this.enable(service);
+    }
+  }
+  register(name, useFunction) {
+    this.__customServices[name] = useFunction;
+    this.__base.__addEmits(name);
+  }
+  unregister(name) {
+    if (SERVICE_NAMES.includes(name)) {
+      throw new Error(`[ServicesManager] The \`${name}\` core service can not be unregistered.`);
+    }
+    this.__base.__removeEmits(name);
+    delete this.__customServices[name];
+  }
+};
+if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/ServicesManager.js

@@ -1,17 +1,17 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-import usePointer from '../../services/pointer.js';
-import useRaf from '../../services/raf.js';
-import useResize from '../../services/resize.js';
-import useScroll from '../../services/scroll.js';
-import useKey from '../../services/key.js';
-import useLoad from '../../services/load.js';
-import { hasMethod } from '../utils.js';
-var SERVICES_MAP = {
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import usePointer from "../../services/pointer.js";
+import useRaf from "../../services/raf.js";
+import useResize from "../../services/resize.js";
+import useScroll from "../../services/scroll.js";
+import useKey from "../../services/key.js";
+import useLoad from "../../services/load.js";
+import { hasMethod } from "../utils.js";
+const SERVICES_MAP = {
   scrolled: useScroll,
   resized: useResize,
   ticked: useRaf,
@@ -19,17 +19,11 @@ var SERVICES_MAP = {
   keyed: useKey,
   loaded: useLoad
 };
-var SERVICE_NAMES = Object.keys(SERVICES_MAP);
-export default class ServicesManager {
-  get __services() {
-    return _objectSpread(_objectSpread({}, this.__customServices), SERVICES_MAP);
-  }
-
+const SERVICE_NAMES = Object.keys(SERVICES_MAP);
+class ServicesManager {
   constructor(instance) {
-    _defineProperty(this, "__base", void 0);
-
-    _defineProperty(this, "__customServices", {});
-
+    __publicField(this, "__base");
+    __publicField(this, "__customServices", {});
     Object.defineProperties(this, {
       __base: {
         enumerable: false,
@@ -38,74 +32,55 @@ export default class ServicesManager {
       }
     });
   }
-
+  get __services() {
+    return {
+      ...this.__customServices,
+      ...SERVICES_MAP
+    };
+  }
   has(service) {
     if (!((hasMethod(this.__base, service) || this.__base.__hasEvent(service)) && this.__services[service])) {
       return false;
     }
-
-    var {
-      has
-    } = this.__services[service]();
-
+    const { has } = this.__services[service]();
     return has(this.__base.$id);
   }
-
   enable(service) {
     if (this.has(service)) {
       return this.disable.bind(this, service);
     }
-
     if (!(hasMethod(this.__base, service) || this.__base.__hasEvent(service)) || !this.__services[service]) {
-      return function noop() {};
+      return function noop() {
+      };
     }
-
-    var {
-      add
-    } = this.__services[service]();
-
-    var self = this;
-
-    function serviceHandler() {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-
+    const { add } = this.__services[service]();
+    const self = this;
+    function serviceHandler(...args) {
       self.__base.__callMethod(service, ...args);
     }
-
     add(this.__base.$id, serviceHandler);
     return this.disable.bind(this, service);
   }
-
   enableAll() {
-    return Object.keys(this.__services).map(serviceName => this.enable(serviceName));
+    return Object.keys(this.__services).map((serviceName) => this.enable(serviceName));
   }
-
   disableAll() {
-    Object.keys(this.__services).forEach(serviceName => {
+    Object.keys(this.__services).forEach((serviceName) => {
       this.disable(serviceName);
     });
   }
-
   disable(service) {
     if (!this.__services[service]) {
       return;
     }
-
-    var {
-      remove
-    } = this.__services[service]();
-
+    const { remove } = this.__services[service]();
     remove(this.__base.$id);
   }
-
   toggle(service, force) {
-    if (typeof force !== 'undefined') {
+    if (typeof force !== "undefined") {
       if (force && !this.has(service)) {
         this.enable(service);
       }
-
       if (!force && this.has(service)) {
         this.disable(service);
       }
@@ -115,21 +90,18 @@ export default class ServicesManager {
       this.enable(service);
     }
   }
-
   register(name, useFunction) {
     this.__customServices[name] = useFunction;
-
     this.__base.__addEmits(name);
   }
-
   unregister(name) {
     if (SERVICE_NAMES.includes(name)) {
-      throw new Error("[ServicesManager] The `".concat(name, "` core service can not be unregistered."));
+      throw new Error(`[ServicesManager] The \`${name}\` core service can not be unregistered.`);
     }
-
     this.__base.__removeEmits(name);
-
     delete this.__customServices[name];
   }
-
-}
+}
+export {
+  ServicesManager as default
+};

package/Base/utils.cjs

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/js-toolkit/Base/utils.js
+var utils_exports = {};
+__export(utils_exports, {
+  getComponentElements: () => getComponentElements,
+  hasMethod: () => hasMethod
+});
+module.exports = __toCommonJS(utils_exports);
+function hasMethod(obj, name) {
+  return typeof obj[name] === "function";
+}
+function getComponentElements(nameOrSelector, element = document) {
+  const selector = `[data-component="${nameOrSelector}"]`;
+  let elements = [];
+  try {
+    elements = Array.from(element.querySelectorAll(selector));
+  } catch {
+  }
+  if (elements.length === 0) {
+    elements = Array.from(element.querySelectorAll(nameOrSelector));
+  }
+  return elements;
+}
+if (module.exports.default) module.exports = module.exports.default;

package/Base/utils.js

@@ -1,18 +1,19 @@
-export function hasMethod(obj, name) {
-  return typeof obj[name] === 'function';
+function hasMethod(obj, name) {
+  return typeof obj[name] === "function";
 }
-export function getComponentElements(nameOrSelector) {
-  var element = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document;
-  var selector = "[data-component=\"".concat(nameOrSelector, "\"]");
-  var elements = [];
-
+function getComponentElements(nameOrSelector, element = document) {
+  const selector = `[data-component="${nameOrSelector}"]`;
+  let elements = [];
   try {
     elements = Array.from(element.querySelectorAll(selector));
-  } catch (_unused) {}
-
+  } catch {
+  }
   if (elements.length === 0) {
     elements = Array.from(element.querySelectorAll(nameOrSelector));
   }
-
   return elements;
-}
+}
+export {
+  getComponentElements,
+  hasMethod
+};

package/README.md

@@ -15,80 +15,23 @@ Install the latest version via NPM:
 npm install @studiometa/js-toolkit
 ```
 
-## Concept
+## Documentation
 
-[] todo
+This project contains a JavaScript micro-framework and its utility functions whose main objectives are:
 
-## Usage
+- Enforcing best-practice and consistency between projects
+- Using elements from the DOM easily
+- Enabling custom behaviours on component initialization or other user events
+- Disabling custom behaviours on component destruction or other user events
+- Initializing components in the right place at the right time
+- Defining dependencies between components
 
-Import the `Base` class and extend it to create your components:
+Visit [js-toolkit.studiometa.dev](https://js-toolkit.studiometa.dev) to learn more.
 
-```js
-import { Base, createApp } from '@studiometa/js-toolkit';
+## Contributing
 
-class Component extends Base {
-  static config = {
-    name: 'Component',
-  }
+This projects follows the [Git Flow](https://github.com/petervanderdoes/gitflow-avh) methodology to manage its branches and features. The packages and their dependencies are managed with NPM workspaces. The files are linted with ESLint, type checked with TypeScript and formatted with Prettier.
 
-  sayHello() {
-    console.log('Hello!');
-  }
-}
+## License
 
-class App extends Base {
-  static config = {
-    name: 'App',
-    components: {
-      Component,
-    },
-    refs: ['btn', 'items[]'],
-    options: {
-      foo: String,
-      bar: { type: String, default: 'bar' },
-    }
-  };
-
-  mounted() {
-    this.$log('mounted');
-
-    // Options
-    this.$options.name; // 'App'
-    this.$options.log; // true
-    this.$options.debug; // false
-    this.$options.foo // ''
-    this.$options.bar // 'bar'
-
-    // Children
-    this.$children.Component; // Array<Component>
-
-    // DOM references
-    this.$refs.btn; // <button data-ref="btn"></button>
-    this.$refs.items[0]; // <li data-ref="items[]"></li>
-  }
-
-  destroyed() {
-    this.$log('destroyed');
-  }
-
-  scrolled(props) {
-    this.$log('scrolled', props);
-  }
-
-  resized(props) {
-    this.$log('resized', props);
-  }
-}
-
-export default createApp(App, document.body);
-```
-
-Read the [documentation](https://js-toolkit.studiometa.dev/) to learn more.
-
-## Contribution
-
-This projects follows the [Git Flow](https://github.com/petervanderdoes/gitflow-avh) methodology to manage its branches and features.
-
-The packages from this project are managed with NPM workspaces.
-
-The files are linted with ESLint, type checked with TypeScript and formatted with Prettier.
+See [LICENSE](./LICENSE).

package/decorators/index.cjs

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/js-toolkit/decorators/index.js
+var decorators_exports = {};
+__export(decorators_exports, {
+  withBreakpointManager: () => import_withBreakpointManager.default,
+  withBreakpointObserver: () => import_withBreakpointObserver.default,
+  withDrag: () => import_withDrag.default,
+  withExtraConfig: () => import_withExtraConfig.default,
+  withFreezedOptions: () => import_withFreezedOptions.default,
+  withIntersectionObserver: () => import_withIntersectionObserver.default,
+  withMountWhenInView: () => import_withMountWhenInView.default,
+  withScrolledInView: () => import_withScrolledInView.default,
+  withVue2: () => import_withVue2.default
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_withBreakpointManager = __toESM(require("./withBreakpointManager.cjs"), 1);
+var import_withBreakpointObserver = __toESM(require("./withBreakpointObserver.cjs"), 1);
+var import_withDrag = __toESM(require("./withDrag.cjs"), 1);
+var import_withExtraConfig = __toESM(require("./withExtraConfig.cjs"), 1);
+var import_withFreezedOptions = __toESM(require("./withFreezedOptions.cjs"), 1);
+var import_withIntersectionObserver = __toESM(require("./withIntersectionObserver.cjs"), 1);
+var import_withMountWhenInView = __toESM(require("./withMountWhenInView.cjs"), 1);
+var import_withScrolledInView = __toESM(require("./withScrolledInView.cjs"), 1);
+var import_withVue2 = __toESM(require("./withVue2.cjs"), 1);
+if (module.exports.default) module.exports = module.exports.default;

package/decorators/index.d.ts

@@ -1,9 +1,9 @@
-import withBreakpointManager from "./withBreakpointManager.js";
-import withBreakpointObserver from "./withBreakpointObserver.js";
-import withDrag from "./withDrag.js";
-import withExtraConfig from "./withExtraConfig.js";
-import withIntersectionObserver from "./withIntersectionObserver.js";
-import withMountWhenInView from "./withMountWhenInView.js";
-import withScrolledInView from "./withScrolledInView.js";
-import withVue2 from "./withVue2.js";
-export { withBreakpointManager, withBreakpointObserver, withDrag, withExtraConfig, withIntersectionObserver, withMountWhenInView, withScrolledInView, withVue2 };
+export { default as withBreakpointManager } from "./withBreakpointManager.js";
+export { default as withBreakpointObserver } from "./withBreakpointObserver.js";
+export { default as withDrag } from "./withDrag.js";
+export { default as withExtraConfig } from "./withExtraConfig.js";
+export { default as withFreezedOptions } from "./withFreezedOptions.js";
+export { default as withIntersectionObserver } from "./withIntersectionObserver.js";
+export { default as withMountWhenInView } from "./withMountWhenInView.js";
+export { default as withScrolledInView } from "./withScrolledInView.js";
+export { default as withVue2 } from "./withVue2.js";

package/decorators/index.js

@@ -1,9 +1,20 @@
-import withBreakpointManager from './withBreakpointManager.js';
-import withBreakpointObserver from './withBreakpointObserver.js';
-import withDrag from './withDrag.js';
-import withExtraConfig from './withExtraConfig.js';
-import withIntersectionObserver from './withIntersectionObserver.js';
-import withMountWhenInView from './withMountWhenInView.js';
-import withScrolledInView from './withScrolledInView.js';
-import withVue2 from './withVue2.js';
-export { withBreakpointManager, withBreakpointObserver, withDrag, withExtraConfig, withIntersectionObserver, withMountWhenInView, withScrolledInView, withVue2 };
+import { default as default2 } from "./withBreakpointManager.js";
+import { default as default3 } from "./withBreakpointObserver.js";
+import { default as default4 } from "./withDrag.js";
+import { default as default5 } from "./withExtraConfig.js";
+import { default as default6 } from "./withFreezedOptions.js";
+import { default as default7 } from "./withIntersectionObserver.js";
+import { default as default8 } from "./withMountWhenInView.js";
+import { default as default9 } from "./withScrolledInView.js";
+import { default as default10 } from "./withVue2.js";
+export {
+  default2 as withBreakpointManager,
+  default3 as withBreakpointObserver,
+  default4 as withDrag,
+  default5 as withExtraConfig,
+  default6 as withFreezedOptions,
+  default7 as withIntersectionObserver,
+  default8 as withMountWhenInView,
+  default9 as withScrolledInView,
+  default10 as withVue2
+};

package/decorators/withBreakpointManager.cjs

@@ -0,0 +1,85 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/js-toolkit/decorators/withBreakpointManager.js
+var withBreakpointManager_exports = {};
+__export(withBreakpointManager_exports, {
+  default: () => withBreakpointManager
+});
+module.exports = __toCommonJS(withBreakpointManager_exports);
+var import_resize = __toESM(require("../services/resize.cjs"), 1);
+function testBreakpoints(breakpoints) {
+  const { breakpoint } = (0, import_resize.default)().props();
+  breakpoints.forEach(([breakpointKeys, instance]) => {
+    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(([bk, ComponentClass]) => {
+    const child = new ComponentClass(instance.$el);
+    Object.defineProperty(child, "$parent", { get: () => instance.$parent });
+    return [bk, child];
+  });
+}
+var instances = /* @__PURE__ */ new WeakMap();
+function withBreakpointManager(BaseClass, breakpoints) {
+  if (!Array.isArray(breakpoints)) {
+    throw new Error("[withBreakpointManager] The `breakpoints` parameter must be an array.");
+  }
+  if (breakpoints.length < 2) {
+    throw new Error("[withBreakpointManager] You must define at least 2 breakpoints.");
+  }
+  const { add, props } = (0, import_resize.default)();
+  if (!props().breakpoint) {
+    throw new Error(`The \`BreakpointManager\` class requires breakpoints to be defined.`);
+  }
+  return class extends BaseClass {
+    constructor(element) {
+      super(element);
+      if (!instances.has(this)) {
+        instances.set(this, mountComponents(this, breakpoints));
+      }
+      add(`BreakpointManager-${this.$id}`, () => {
+        testBreakpoints(instances.get(this));
+      });
+      this.instances = instances.get(this);
+      return this;
+    }
+    $mount() {
+      super.$mount();
+      testBreakpoints(instances.get(this));
+      return this;
+    }
+    $destroy() {
+      if (Array.isArray(instances.get(this))) {
+        instances.get(this).forEach(([, instance]) => {
+          instance.$destroy();
+        });
+      }
+      return super.$destroy();
+    }
+  };
+}
+if (module.exports.default) module.exports = module.exports.default;