@studiometa/js-toolkit 2.2.2 → 2.4.0

package/Base/managers/OptionsManager.cjs

@@ -33,7 +33,7 @@ __export(OptionsManager_exports, {
 module.exports = __toCommonJS(OptionsManager_exports);
 var import_deepmerge = __toESM(require("deepmerge"), 1);
 var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
-var import_isObject = __toESM(require("../../utils/object/isObject.cjs"), 1);
+var import_utils = require("../../utils/index.cjs");
 var types = /* @__PURE__ */ new Set([String, Number, Boolean, Array, Object]);
 var __defaultValues = {
   String: "",
@@ -42,9 +42,6 @@ var __defaultValues = {
   Array: () => [],
   Object: () => ({})
 };
-function __hasProperty(that, prop) {
-  return typeof that.__element.dataset[prop] !== "undefined";
-}
 var __propertyNameCache = /* @__PURE__ */ new Map();
 function __getPropertyName(name, prefix = "") {
   const key = name + prefix;
@@ -58,11 +55,17 @@ function __getPropertyName(name, prefix = "") {
 function __register(that, name, config) {
   var _a;
   if (!types.has(config.type)) {
-    throw new Error(`The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`);
+    if (import_utils.isDev) {
+      throw new Error(`The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`);
+    }
+    return;
   }
   config.default = (_a = config.default) != null ? _a : __defaultValues[config.type.name];
-  if ((config.type === Array || config.type === Object) && typeof config.default !== "function") {
-    throw new Error(`The default value for options of type "${config.type.name}" must be returned by a function.`);
+  if ((config.type === Array || config.type === Object) && !(0, import_utils.isFunction)(config.default)) {
+    if (import_utils.isDev) {
+      throw new Error(`The default value for options of type "${config.type.name}" must be returned by a function.`);
+    }
+    return;
   }
   Object.defineProperty(that, name, {
     get: () => {
@@ -100,11 +103,11 @@ var OptionsManager = class extends import_AbstractManager.default {
   get(name, config) {
     const { type, default: defaultValue } = config;
     const propertyName = __getPropertyName(name);
-    const hasProperty = __hasProperty(this, propertyName);
+    const hasProperty = (0, import_utils.isDefined)(this.__element.dataset[propertyName]);
     if (type === Boolean) {
       if (defaultValue) {
         const negatedPropertyName = __getPropertyName(name, "No");
-        const hasNegatedProperty = __hasProperty(this, negatedPropertyName);
+        const hasNegatedProperty = (0, import_utils.isDefined)(this.__element.dataset[negatedPropertyName]);
         return !hasNegatedProperty;
       }
       return hasProperty || defaultValue;
@@ -117,8 +120,8 @@ var OptionsManager = class extends import_AbstractManager.default {
       config = type === Array ? config : config;
       if (!this.__values[name]) {
         let val = hasProperty ? JSON.parse(value) : config.default();
-        if (typeof config.merge !== "undefined") {
-          val = typeof config.merge === "boolean" ? (0, import_deepmerge.default)(config.default(), val) : (0, import_deepmerge.default)(config.default(), val, config.merge);
+        if ((0, import_utils.isDefined)(config.merge)) {
+          val = (0, import_utils.isBoolean)(config.merge) ? (0, import_deepmerge.default)(config.default(), val) : (0, import_deepmerge.default)(config.default(), val, config.merge);
         }
         this.__values[name] = val;
       }
@@ -130,8 +133,11 @@ var OptionsManager = class extends import_AbstractManager.default {
     const { type, default: defaultValue } = config;
     const propertyName = __getPropertyName(name);
     if (value.constructor.name !== type.name) {
-      const val = Array.isArray(value) || (0, import_isObject.default)(value) ? JSON.stringify(value) : value;
-      throw new TypeError(`The "${val}" value for the "${name}" option must be of type "${type.name}"`);
+      if (import_utils.isDev) {
+        const val = (0, import_utils.isArray)(value) || (0, import_utils.isObject)(value) ? JSON.stringify(value) : value;
+        throw new TypeError(`The "${val}" value for the "${name}" option must be of type "${type.name}"`);
+      }
+      return;
     }
     switch (type) {
       case Boolean:

package/Base/managers/OptionsManager.js

@@ -6,7 +6,7 @@ var __publicField = (obj, key, value) => {
 };
 import deepmerge from "deepmerge";
 import AbstractManager from "./AbstractManager.js";
-import isObject from "../../utils/object/isObject.js";
+import { isDev, isFunction, isDefined, isBoolean, isArray, isObject } from "../../utils/index.js";
 const types = /* @__PURE__ */ new Set([String, Number, Boolean, Array, Object]);
 const __defaultValues = {
   String: "",
@@ -15,9 +15,6 @@ const __defaultValues = {
   Array: () => [],
   Object: () => ({})
 };
-function __hasProperty(that, prop) {
-  return typeof that.__element.dataset[prop] !== "undefined";
-}
 const __propertyNameCache = /* @__PURE__ */ new Map();
 function __getPropertyName(name, prefix = "") {
   const key = name + prefix;
@@ -31,11 +28,17 @@ function __getPropertyName(name, prefix = "") {
 function __register(that, name, config) {
   var _a;
   if (!types.has(config.type)) {
-    throw new Error(`The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`);
+    if (isDev) {
+      throw new Error(`The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`);
+    }
+    return;
   }
   config.default = (_a = config.default) != null ? _a : __defaultValues[config.type.name];
-  if ((config.type === Array || config.type === Object) && typeof config.default !== "function") {
-    throw new Error(`The default value for options of type "${config.type.name}" must be returned by a function.`);
+  if ((config.type === Array || config.type === Object) && !isFunction(config.default)) {
+    if (isDev) {
+      throw new Error(`The default value for options of type "${config.type.name}" must be returned by a function.`);
+    }
+    return;
   }
   Object.defineProperty(that, name, {
     get: () => {
@@ -73,11 +76,11 @@ class OptionsManager extends AbstractManager {
   get(name, config) {
     const { type, default: defaultValue } = config;
     const propertyName = __getPropertyName(name);
-    const hasProperty = __hasProperty(this, propertyName);
+    const hasProperty = isDefined(this.__element.dataset[propertyName]);
     if (type === Boolean) {
       if (defaultValue) {
         const negatedPropertyName = __getPropertyName(name, "No");
-        const hasNegatedProperty = __hasProperty(this, negatedPropertyName);
+        const hasNegatedProperty = isDefined(this.__element.dataset[negatedPropertyName]);
         return !hasNegatedProperty;
       }
       return hasProperty || defaultValue;
@@ -90,8 +93,8 @@ class OptionsManager extends AbstractManager {
       config = type === Array ? config : config;
       if (!this.__values[name]) {
         let val = hasProperty ? JSON.parse(value) : config.default();
-        if (typeof config.merge !== "undefined") {
-          val = typeof config.merge === "boolean" ? deepmerge(config.default(), val) : deepmerge(config.default(), val, config.merge);
+        if (isDefined(config.merge)) {
+          val = isBoolean(config.merge) ? deepmerge(config.default(), val) : deepmerge(config.default(), val, config.merge);
         }
         this.__values[name] = val;
       }
@@ -103,8 +106,11 @@ class OptionsManager extends AbstractManager {
     const { type, default: defaultValue } = config;
     const propertyName = __getPropertyName(name);
     if (value.constructor.name !== type.name) {
-      const val = Array.isArray(value) || isObject(value) ? JSON.stringify(value) : value;
-      throw new TypeError(`The "${val}" value for the "${name}" option must be of type "${type.name}"`);
+      if (isDev) {
+        const val = isArray(value) || isObject(value) ? JSON.stringify(value) : value;
+        throw new TypeError(`The "${val}" value for the "${name}" option must be of type "${type.name}"`);
+      }
+      return;
     }
     switch (type) {
       case Boolean:

package/Base/managers/RefsManager.cjs

@@ -27,12 +27,13 @@ __export(RefsManager_exports, {
 });
 module.exports = __toCommonJS(RefsManager_exports);
 var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+var import_utils = require("../../utils/index.cjs");
 function normalizeRefName(name) {
   return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
 }
 function __filterRefsBelongingToInstance(that, ref) {
   let ancestor = ref.parentElement;
-  while (ancestor && ancestor.dataset.component === void 0) {
+  while (ancestor && !(0, import_utils.isDefined)(ancestor.dataset.component)) {
     ancestor = ancestor.parentElement;
   }
   return ancestor === null || ancestor === that.__element;
@@ -41,11 +42,13 @@ function __register(that, refName) {
   const isMultiple = refName.endsWith("[]");
   const propName = normalizeRefName(refName);
   const refs = Array.from(that.__element.querySelectorAll(`[data-ref="${refName}"]`)).filter((ref) => __filterRefsBelongingToInstance(that, ref));
-  if (!isMultiple && refs.length > 1) {
+  if (import_utils.isDev && !isMultiple && refs.length > 1) {
     console.warn(`[${that.__base.$options.name}]`, `The "${refName}" ref has been found multiple times.`, "Did you forgot to add the `[]` suffix to its name?");
   }
-  if (!isMultiple && refs.length <= 1 && refs[0] === void 0) {
-    console.warn(`[${that.__base.$options.name}]`, `The "${refName}" ref is missing.`, `Is there an \`[data-ref="${refName}"]\` element in the component's scope?`);
+  if (!isMultiple && refs.length <= 1 && !(0, import_utils.isDefined)(refs[0])) {
+    if (import_utils.isDev) {
+      console.warn(`[${that.__base.$options.name}]`, `The "${refName}" ref is missing.`, `Is there an \`[data-ref="${refName}"]\` element in the component's scope?`);
+    }
     return;
   }
   that.__eventsManager.bindRef(refName, refs);
@@ -57,7 +60,7 @@ function __register(that, refName) {
 }
 function __unregister(that, refName) {
   const propName = normalizeRefName(refName);
-  const refs = Array.isArray(that[propName]) ? that[propName] : [that[propName]];
+  const refs = (0, import_utils.isArray)(that[propName]) ? that[propName] : [that[propName]];
   that.__eventsManager.unbindRef(refName, refs);
 }
 var RefsManager = class extends import_AbstractManager.default {

package/Base/managers/RefsManager.js

@@ -1,10 +1,11 @@
 import AbstractManager from "./AbstractManager.js";
+import { isDev, isArray, isDefined } from "../../utils/index.js";
 function normalizeRefName(name) {
   return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
 }
 function __filterRefsBelongingToInstance(that, ref) {
   let ancestor = ref.parentElement;
-  while (ancestor && ancestor.dataset.component === void 0) {
+  while (ancestor && !isDefined(ancestor.dataset.component)) {
     ancestor = ancestor.parentElement;
   }
   return ancestor === null || ancestor === that.__element;
@@ -13,11 +14,13 @@ function __register(that, refName) {
   const isMultiple = refName.endsWith("[]");
   const propName = normalizeRefName(refName);
   const refs = Array.from(that.__element.querySelectorAll(`[data-ref="${refName}"]`)).filter((ref) => __filterRefsBelongingToInstance(that, ref));
-  if (!isMultiple && refs.length > 1) {
+  if (isDev && !isMultiple && refs.length > 1) {
     console.warn(`[${that.__base.$options.name}]`, `The "${refName}" ref has been found multiple times.`, "Did you forgot to add the `[]` suffix to its name?");
   }
-  if (!isMultiple && refs.length <= 1 && refs[0] === void 0) {
-    console.warn(`[${that.__base.$options.name}]`, `The "${refName}" ref is missing.`, `Is there an \`[data-ref="${refName}"]\` element in the component's scope?`);
+  if (!isMultiple && refs.length <= 1 && !isDefined(refs[0])) {
+    if (isDev) {
+      console.warn(`[${that.__base.$options.name}]`, `The "${refName}" ref is missing.`, `Is there an \`[data-ref="${refName}"]\` element in the component's scope?`);
+    }
     return;
   }
   that.__eventsManager.bindRef(refName, refs);
@@ -29,7 +32,7 @@ function __register(that, refName) {
 }
 function __unregister(that, refName) {
   const propName = normalizeRefName(refName);
-  const refs = Array.isArray(that[propName]) ? that[propName] : [that[propName]];
+  const refs = isArray(that[propName]) ? that[propName] : [that[propName]];
   that.__eventsManager.unbindRef(refName, refs);
 }
 class RefsManager extends AbstractManager {

package/Base/managers/ResponsiveOptionsManager.cjs

@@ -27,6 +27,7 @@ __export(ResponsiveOptionsManager_exports, {
 module.exports = __toCommonJS(ResponsiveOptionsManager_exports);
 var import_OptionsManager = __toESM(require("./OptionsManager.cjs"), 1);
 var import_services = require("../../services/index.cjs");
+var import_utils = require("../../utils/index.cjs");
 function __getResponsiveName(that, name) {
   const { breakpoint } = (0, import_services.useResize)().props();
   if (!breakpoint) {
@@ -56,7 +57,9 @@ var ResponsiveOptionsManager = class extends import_OptionsManager.default {
       super.set(name, value, config);
       return;
     }
-    console.warn(`[${this.__config.name}]`, "Responsive options are read-only.");
+    if (import_utils.isDev) {
+      console.warn(`[${this.__config.name}]`, "Responsive options are read-only.");
+    }
   }
 };
 if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/ResponsiveOptionsManager.js

@@ -1,5 +1,6 @@
 import OptionsManager, { __getPropertyName } from "./OptionsManager.js";
 import { useResize } from "../../services/index.js";
+import { isDev } from "../../utils/index.js";
 function __getResponsiveName(that, name) {
   const { breakpoint } = useResize().props();
   if (!breakpoint) {
@@ -29,7 +30,9 @@ class ResponsiveOptionsManager extends OptionsManager {
       super.set(name, value, config);
       return;
     }
-    console.warn(`[${this.__config.name}]`, "Responsive options are read-only.");
+    if (isDev) {
+      console.warn(`[${this.__config.name}]`, "Responsive options are read-only.");
+    }
   }
 }
 export {

package/Base/managers/ServicesManager.cjs

@@ -37,7 +37,7 @@ 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_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
-var import_utils = require("../utils.cjs");
+var import_utils = require("../../utils/index.cjs");
 var SERVICES_MAP = {
   scrolled: import_scroll.default,
   resized: import_resize.default,
@@ -59,7 +59,7 @@ var ServicesManager = class extends import_AbstractManager.default {
     };
   }
   has(service) {
-    if (!(((0, import_utils.hasMethod)(this.__base, service) || this.__base.__hasEvent(service)) && this.__services[service])) {
+    if (!(((0, import_utils.isFunction)(this.__base[service]) || this.__base.__hasEvent(service)) && this.__services[service])) {
       return false;
     }
     const { has } = this.__services[service]();
@@ -72,9 +72,8 @@ var ServicesManager = class extends import_AbstractManager.default {
     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() {
-      };
+    if (!((0, import_utils.isFunction)(this.__base[service]) || this.__base.__hasEvent(service)) || !this.__services[service]) {
+      return import_utils.noop;
     }
     const { add } = this.__services[service]();
     const self = this;
@@ -100,7 +99,7 @@ var ServicesManager = class extends import_AbstractManager.default {
     remove(this.__base.$id);
   }
   toggle(service, force) {
-    if (typeof force !== "undefined") {
+    if ((0, import_utils.isDefined)(force)) {
       if (force && !this.has(service)) {
         this.enable(service);
       }
@@ -119,7 +118,10 @@ var ServicesManager = class extends import_AbstractManager.default {
   }
   unregister(name) {
     if (SERVICE_NAMES.includes(name)) {
-      throw new Error(`[ServicesManager] The \`${name}\` core service can not be unregistered.`);
+      if (import_utils.isDev) {
+        throw new Error(`[ServicesManager] The \`${name}\` core service can not be unregistered.`);
+      }
+      return;
     }
     this.__base.__removeEmits(name);
     delete this.__customServices[name];

package/Base/managers/ServicesManager.js

@@ -11,7 +11,7 @@ import useScroll from "../../services/scroll.js";
 import useKey from "../../services/key.js";
 import useLoad from "../../services/load.js";
 import AbstractManager from "./AbstractManager.js";
-import { hasMethod } from "../utils.js";
+import { noop, isFunction, isDefined, isDev } from "../../utils/index.js";
 const SERVICES_MAP = {
   scrolled: useScroll,
   resized: useResize,
@@ -33,7 +33,7 @@ class ServicesManager extends AbstractManager {
     };
   }
   has(service) {
-    if (!((hasMethod(this.__base, service) || this.__base.__hasEvent(service)) && this.__services[service])) {
+    if (!((isFunction(this.__base[service]) || this.__base.__hasEvent(service)) && this.__services[service])) {
       return false;
     }
     const { has } = this.__services[service]();
@@ -46,9 +46,8 @@ class ServicesManager extends AbstractManager {
     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() {
-      };
+    if (!(isFunction(this.__base[service]) || this.__base.__hasEvent(service)) || !this.__services[service]) {
+      return noop;
     }
     const { add } = this.__services[service]();
     const self = this;
@@ -74,7 +73,7 @@ class ServicesManager extends AbstractManager {
     remove(this.__base.$id);
   }
   toggle(service, force) {
-    if (typeof force !== "undefined") {
+    if (isDefined(force)) {
       if (force && !this.has(service)) {
         this.enable(service);
       }
@@ -93,7 +92,10 @@ class ServicesManager extends AbstractManager {
   }
   unregister(name) {
     if (SERVICE_NAMES.includes(name)) {
-      throw new Error(`[ServicesManager] The \`${name}\` core service can not be unregistered.`);
+      if (isDev) {
+        throw new Error(`[ServicesManager] The \`${name}\` core service can not be unregistered.`);
+      }
+      return;
     }
     this.__base.__removeEmits(name);
     delete this.__customServices[name];

package/Base/utils.cjs

@@ -19,13 +19,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // packages/js-toolkit/Base/utils.js
 var utils_exports = {};
 __export(utils_exports, {
+  eventIsDefinedInConfig: () => eventIsDefinedInConfig,
+  eventIsNative: () => eventIsNative,
   getComponentElements: () => getComponentElements,
-  hasMethod: () => hasMethod
+  getEventTarget: () => getEventTarget
 });
 module.exports = __toCommonJS(utils_exports);
-function hasMethod(obj, name) {
-  return typeof obj[name] === "function";
-}
+var import_utils = require("../utils/index.cjs");
 function getComponentElements(nameOrSelector, element = document) {
   const selector = `[data-component="${nameOrSelector}"]`;
   let elements = [];
@@ -38,4 +38,22 @@ function getComponentElements(nameOrSelector, element = document) {
   }
   return elements;
 }
+function eventIsDefinedInConfig(event, config) {
+  return (0, import_utils.isArray)(config.emits) && config.emits.includes(event);
+}
+function eventIsNative(event, element) {
+  return (0, import_utils.isDefined)(element[`on${event}`]);
+}
+function getEventTarget(instance, event, config) {
+  if (eventIsDefinedInConfig(event, config)) {
+    return instance;
+  }
+  if (eventIsNative(event, instance.$el)) {
+    return instance.$el;
+  }
+  if (import_utils.isDev) {
+    console.warn(`[${config.name}]`, `The "${event}" event is missing from the configuration and is not a native`, `event for the root element of type \`${instance.$el.constructor.name}\`.`);
+  }
+  return instance;
+}
 if (module.exports.default) module.exports = module.exports.default;

package/Base/utils.d.ts

@@ -1,14 +1,6 @@
 /**
  * @typedef {import('./index.js').default} Base
  */
-/**
- * Test if an object has a method.
- *
- * @param  {Object}  obj  The object to test
- * @param  {string}  name The method's name
- * @returns {boolean}
- */
-export function hasMethod(obj: any, name: string): boolean;
 /**
  * Get a list of elements based on the name of a component.
  *
@@ -20,4 +12,29 @@ export function hasMethod(obj: any, name: string): boolean;
  *   A list of elements on which the component should be mounted.
  */
 export function getComponentElements(nameOrSelector: string, element?: HTMLElement | Document): Array<HTMLElement>;
+/**
+ * Test if an event is defined in the given config.
+ *
+ * @param   {string} event
+ * @param   {import('./index.js').BaseConfig} config
+ * @returns {boolean}
+ */
+export function eventIsDefinedInConfig(event: string, config: import('./index.js').BaseConfig): boolean;
+/**
+ * Test if an event can be used on the given element.
+ *
+ * @param   {string} event
+ * @param   {HTMLElement} element
+ * @returns {boolean}
+ */
+export function eventIsNative(event: string, element: HTMLElement): boolean;
+/**
+ * Get the target of a given event.
+ *
+ * @param   {Base} instance
+ * @param   {string} event
+ * @param   {import('./index.js').BaseConfig} config
+ * @returns {Base|Base['$el']}
+ */
+export function getEventTarget(instance: Base, event: string, config: import('./index.js').BaseConfig): Base | Base['$el'];
 export type Base = import('./index.js').default;

package/Base/utils.js

@@ -1,6 +1,4 @@
-function hasMethod(obj, name) {
-  return typeof obj[name] === "function";
-}
+import { isArray, isDefined, isDev } from "../utils/index.js";
 function getComponentElements(nameOrSelector, element = document) {
   const selector = `[data-component="${nameOrSelector}"]`;
   let elements = [];
@@ -13,7 +11,27 @@ function getComponentElements(nameOrSelector, element = document) {
   }
   return elements;
 }
+function eventIsDefinedInConfig(event, config) {
+  return isArray(config.emits) && config.emits.includes(event);
+}
+function eventIsNative(event, element) {
+  return isDefined(element[`on${event}`]);
+}
+function getEventTarget(instance, event, config) {
+  if (eventIsDefinedInConfig(event, config)) {
+    return instance;
+  }
+  if (eventIsNative(event, instance.$el)) {
+    return instance.$el;
+  }
+  if (isDev) {
+    console.warn(`[${config.name}]`, `The "${event}" event is missing from the configuration and is not a native`, `event for the root element of type \`${instance.$el.constructor.name}\`.`);
+  }
+  return instance;
+}
 export {
+  eventIsDefinedInConfig,
+  eventIsNative,
   getComponentElements,
-  hasMethod
+  getEventTarget
 };

package/README.md

@@ -5,7 +5,7 @@
 [![Dependency Status](https://img.shields.io/librariesio/release/npm/@studiometa/js-toolkit?style=flat-square)](https://david-dm.org/studiometa/js-toolkit)
 ![Codecov](https://img.shields.io/codecov/c/github/studiometa/js-toolkit?style=flat-square)
 
-> A set of useful little bits of JavaScript to boost your project! 🚀
+> A JavaScript data-attributes driven micro-framework shipped with plenty of useful utility functions to boost your project.
 
 ## Installation
 
@@ -15,9 +15,9 @@ Install the latest version via NPM:
 npm install @studiometa/js-toolkit
 ```
 
-## Documentation
+## What is it?
 
-This project contains a JavaScript micro-framework and its utility functions whose main objectives are:
+This project is a JavaScript micro-framework (along with its utility functions) whose main objectives are:
 
 - Enforcing best-practice and consistency between projects
 - Using elements from the DOM easily

package/decorators/withBreakpointManager.cjs

@@ -26,6 +26,7 @@ __export(withBreakpointManager_exports, {
 });
 module.exports = __toCommonJS(withBreakpointManager_exports);
 var import_resize = __toESM(require("../services/resize.cjs"), 1);
+var import_utils = require("../utils/index.cjs");
 function testBreakpoints(breakpoints) {
   const { breakpoint } = (0, import_resize.default)().props();
   breakpoints.forEach(([breakpointKeys, instance]) => {
@@ -45,15 +46,24 @@ function mountComponents(instance, breakpoints) {
 }
 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 (!(0, import_utils.isArray)(breakpoints)) {
+    if (import_utils.isDev) {
+      throw new Error("[withBreakpointManager] The `breakpoints` parameter must be an array.");
+    }
+    return BaseClass;
   }
   if (breakpoints.length < 2) {
-    throw new Error("[withBreakpointManager] You must define at least 2 breakpoints.");
+    if (import_utils.isDev) {
+      throw new Error("[withBreakpointManager] You must define at least 2 breakpoints.");
+    }
+    return BaseClass;
   }
   const { add, props } = (0, import_resize.default)();
   if (!props().breakpoint) {
-    throw new Error(`The \`BreakpointManager\` class requires breakpoints to be defined.`);
+    if (import_utils.isDev) {
+      throw new Error(`The \`BreakpointManager\` class requires breakpoints to be defined.`);
+    }
+    return BaseClass;
   }
   return class extends BaseClass {
     constructor(element) {
@@ -72,7 +82,7 @@ function withBreakpointManager(BaseClass, breakpoints) {
       return this;
     }
     $destroy() {
-      if (Array.isArray(instances.get(this))) {
+      if ((0, import_utils.isArray)(instances.get(this))) {
         instances.get(this).forEach(([, instance]) => {
           instance.$destroy();
         });

package/decorators/withBreakpointManager.js

@@ -1,4 +1,5 @@
 import useResize from "../services/resize.js";
+import { isDev, isArray } from "../utils/index.js";
 function testBreakpoints(breakpoints) {
   const { breakpoint } = useResize().props();
   breakpoints.forEach(([breakpointKeys, instance]) => {
@@ -18,15 +19,24 @@ function mountComponents(instance, breakpoints) {
 }
 const instances = /* @__PURE__ */ new WeakMap();
 function withBreakpointManager(BaseClass, breakpoints) {
-  if (!Array.isArray(breakpoints)) {
-    throw new Error("[withBreakpointManager] The `breakpoints` parameter must be an array.");
+  if (!isArray(breakpoints)) {
+    if (isDev) {
+      throw new Error("[withBreakpointManager] The `breakpoints` parameter must be an array.");
+    }
+    return BaseClass;
   }
   if (breakpoints.length < 2) {
-    throw new Error("[withBreakpointManager] You must define at least 2 breakpoints.");
+    if (isDev) {
+      throw new Error("[withBreakpointManager] You must define at least 2 breakpoints.");
+    }
+    return BaseClass;
   }
   const { add, props } = useResize();
   if (!props().breakpoint) {
-    throw new Error(`The \`BreakpointManager\` class requires breakpoints to be defined.`);
+    if (isDev) {
+      throw new Error(`The \`BreakpointManager\` class requires breakpoints to be defined.`);
+    }
+    return BaseClass;
   }
   return class extends BaseClass {
     constructor(element) {
@@ -45,7 +55,7 @@ function withBreakpointManager(BaseClass, breakpoints) {
       return this;
     }
     $destroy() {
-      if (Array.isArray(instances.get(this))) {
+      if (isArray(instances.get(this))) {
         instances.get(this).forEach(([, instance]) => {
           instance.$destroy();
         });

package/decorators/withBreakpointObserver.cjs

@@ -31,6 +31,7 @@ __export(withBreakpointObserver_exports, {
 });
 module.exports = __toCommonJS(withBreakpointObserver_exports);
 var import_resize = __toESM(require("../services/resize.cjs"), 1);
+var import_utils = require("../utils/index.cjs");
 function testBreakpoints(instance, breakpoint = (0, import_resize.default)().props().breakpoint) {
   const { activeBreakpoints, inactiveBreakpoints } = instance.$options;
   const isInActiveBreakpoint = activeBreakpoints && activeBreakpoints.split(" ").includes(breakpoint);
@@ -51,7 +52,9 @@ function testConflictingBreakpointConfiguration(instance) {
   }
 }
 function addToResize(key, instance) {
-  testConflictingBreakpointConfiguration(instance);
+  if (import_utils.isDev) {
+    testConflictingBreakpointConfiguration(instance);
+  }
   const { add, has } = (0, import_resize.default)();
   if (!has(key)) {
     add(key, function onResize({ breakpoint }) {
@@ -72,7 +75,10 @@ function withBreakpointObserver(BaseClass) {
       const { remove, props } = (0, import_resize.default)();
       const { name } = this.$options;
       if (!props().breakpoint) {
-        throw new Error(`[${name}] The \`BreakpointObserver\` class requires breakpoints to be defined.`);
+        if (import_utils.isDev) {
+          throw new Error(`[${name}] The \`BreakpointObserver\` class requires breakpoints to be defined.`);
+        }
+        return;
       }
       const key = `BreakpointObserver-${this.$id}`;
       const mutationObserver = new MutationObserver(([mutation]) => {