@studiometa/js-toolkit 2.2.1 → 2.3.0

package/Base/managers/EventsManager.cjs

@@ -4,7 +4,6 @@ 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 });
@@ -19,10 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 };
 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/EventsManager.js
 var EventsManager_exports = {};
@@ -33,6 +28,8 @@ __export(EventsManager_exports, {
 });
 module.exports = __toCommonJS(EventsManager_exports);
 var import_getAllProperties = __toESM(require("../../utils/object/getAllProperties.cjs"), 1);
+var import_utils = require("../../utils/index.cjs");
+var import_utils2 = require("../utils.cjs");
 var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
 var import_RefsManager = require("./RefsManager.cjs");
 var names = /* @__PURE__ */ new Map();
@@ -56,12 +53,12 @@ function getRegex(regex) {
   }
   return regexes.get(regex);
 }
-function __getEventNameByMethod(that, method, name = "") {
+function getEventNameByMethod(method, name = "") {
   const regex = getRegex(`^on${normalizeName(name)}([A-Z].*)$`);
   const [, event] = method.match(regex);
   return normalizeEventName(event);
 }
-function __getEventMethodsByName(that, name = "") {
+function getEventMethodsByName(that, name = "") {
   const regex = getRegex(`^on${normalizeName(name)}[A-Z].*$`);
   const key = regex.toString();
   let methods = that.__methodsCache.get(key);
@@ -71,78 +68,75 @@ function __getEventMethodsByName(that, name = "") {
   }
   return methods;
 }
-function __manageRef(that, name, elements, mode = "add") {
+function manageRef(that, name, elements, mode = "add") {
   const action = `${mode}EventListener`;
-  const methods = __getEventMethodsByName(that, name);
+  const methods = getEventMethodsByName(that, name);
   methods.forEach((method) => {
-    const event = __getEventNameByMethod(that, method, name);
+    const event = getEventNameByMethod(method, name);
     elements.forEach((element) => element[action](event, that.__refsHandler));
   });
 }
-function __manageChild(that, name, instance, mode = "add") {
+function manageChild(that, name, instance, mode = "add") {
   const action = mode === "add" ? "$on" : "$off";
-  const methods = __getEventMethodsByName(that, name);
+  const methods = getEventMethodsByName(that, name);
   methods.forEach((method) => {
-    const event = __getEventNameByMethod(that, method, name);
+    const event = getEventNameByMethod(method, name);
     instance[action](event, that.__childrenHandler);
   });
 }
-function __manageRootElement(that, mode = "add") {
+function manageRootElement(that, mode = "add") {
   const modeMethod = `${mode}EventListener`;
-  const methods = __getEventMethodsByName(that);
-  const { emits = [] } = that.__base.__config;
-  methods.forEach((method) => {
-    const event = __getEventNameByMethod(that, method);
-    const target = emits.includes(event) ? that.__base : that.__element;
+  const methods = getEventMethodsByName(that);
+  const { __base: base, __config: config } = that;
+  methods.map((method) => getEventNameByMethod(method)).filter((event) => (0, import_utils2.eventIsDefinedInConfig)(event, config) || (0, import_utils2.eventIsNative)(event, base.$el)).forEach((event) => {
+    const target = (0, import_utils2.getEventTarget)(base, event, config);
     target[modeMethod](event, that.__rootElementHandler);
   });
 }
 var EventsManager = class extends import_AbstractManager.default {
-  constructor(base) {
-    super(base);
-    __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());
-    __publicField(this, "__rootElementHandler", {
-      handleEvent: (event) => {
-        const normalizedEventName = normalizeName(event.type);
-        const method = `on${normalizedEventName}`;
+  __methodsCache = /* @__PURE__ */ new Map();
+  __rootElementHandler = {
+    handleEvent: (event) => {
+      const normalizedEventName = normalizeName(event.type);
+      const method = `on${normalizedEventName}`;
+      if (event instanceof CustomEvent && (0, import_utils.isArray)(event.detail) && event.detail.length) {
+        this.__base[method](...event.detail, event);
+      } else {
         this.__base[method](event);
       }
-    });
-    __publicField(this, "__refsHandler", {
-      handleEvent: (event) => {
-        const ref = event.currentTarget;
-        const refName = (0, import_RefsManager.normalizeRefName)(ref.dataset.ref);
-        const normalizedRefName = normalizeName(refName);
-        const normalizedEventName = normalizeName(event.type);
-        const method = `on${normalizedRefName}${normalizedEventName}`;
-        let index = 0;
-        if (Array.isArray(this.__base.$refs[refName])) {
-          index = this.__base.$refs[refName].indexOf(ref);
-        }
-        this.__base[method](event, index);
+    }
+  };
+  __refsHandler = {
+    handleEvent: (event) => {
+      const ref = event.currentTarget;
+      const refName = (0, import_RefsManager.normalizeRefName)(ref.dataset.ref);
+      const normalizedRefName = normalizeName(refName);
+      const normalizedEventName = normalizeName(event.type);
+      const method = `on${normalizedRefName}${normalizedEventName}`;
+      let index = 0;
+      if ((0, import_utils.isArray)(this.__base.$refs[refName])) {
+        index = this.__base.$refs[refName].indexOf(ref);
       }
-    });
-    __publicField(this, "__childrenHandler", {
-      handleEvent: (event) => {
-        const child = event.currentTarget;
-        let childName;
-        let index = 0;
-        const childrenManager = this.__base.$children;
-        childrenManager.registeredNames.find((name) => {
-          if (childrenManager[name].includes(child)) {
-            childName = name;
-            index = childrenManager[name].indexOf(child);
-            return true;
-          }
-          return false;
-        });
-        const normalizedRefName = normalizeName(childName);
-        const normalizedEventName = normalizeName(event.type);
-        const method = `on${normalizedRefName}${normalizedEventName}`;
-        const args = Array.isArray(event.detail) ? event.detail : [];
-        this.__base[method](...args, index, event);
-      }
-    });
+      this.__base[method](event, index);
+    }
+  };
+  __childrenHandler = {
+    handleEvent: (event) => {
+      const childrenManager = this.__base.$children;
+      const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
+        name: childName,
+        child: childrenManager[childName].find((instance) => instance === event.currentTarget || instance.$el === event.currentTarget)
+      })).find(({ child }) => child);
+      const normalizedChildName = normalizeName(name);
+      const normalizedEventName = normalizeName(event.type);
+      const method = `on${normalizedChildName}${normalizedEventName}`;
+      const index = childrenManager[name].indexOf(resolvedChild);
+      const args = (0, import_utils.isArray)(event.detail) ? event.detail : [];
+      this.__base[method](...args, index, event);
+    }
+  };
+  constructor(base) {
+    super(base);
     this.__hideProperties([
       "__methodsCache",
       "__rootElementHandler",
@@ -151,22 +145,22 @@ var EventsManager = class extends import_AbstractManager.default {
     ]);
   }
   bindRef(name, elements) {
-    __manageRef(this, name, elements);
+    manageRef(this, name, elements);
   }
   unbindRef(name, elements) {
-    __manageRef(this, name, elements, "remove");
+    manageRef(this, name, elements, "remove");
   }
   bindChild(name, instance) {
-    __manageChild(this, name, instance);
+    manageChild(this, name, instance);
   }
   unbindChild(name, instance) {
-    __manageChild(this, name, instance, "remove");
+    manageChild(this, name, instance, "remove");
   }
   bindRootElement() {
-    __manageRootElement(this);
+    manageRootElement(this);
   }
   unbindRootElement() {
-    __manageRootElement(this, "remove");
+    manageRootElement(this, "remove");
   }
 };
 if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/EventsManager.js

@@ -1,10 +1,6 @@
-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 getAllProperties from "../../utils/object/getAllProperties.js";
+import { isArray } from "../../utils/index.js";
+import { getEventTarget, eventIsNative, eventIsDefinedInConfig } from "../utils.js";
 import AbstractManager from "./AbstractManager.js";
 import { normalizeRefName } from "./RefsManager.js";
 const names = /* @__PURE__ */ new Map();
@@ -28,12 +24,12 @@ function getRegex(regex) {
   }
   return regexes.get(regex);
 }
-function __getEventNameByMethod(that, method, name = "") {
+function getEventNameByMethod(method, name = "") {
   const regex = getRegex(`^on${normalizeName(name)}([A-Z].*)$`);
   const [, event] = method.match(regex);
   return normalizeEventName(event);
 }
-function __getEventMethodsByName(that, name = "") {
+function getEventMethodsByName(that, name = "") {
   const regex = getRegex(`^on${normalizeName(name)}[A-Z].*$`);
   const key = regex.toString();
   let methods = that.__methodsCache.get(key);
@@ -43,78 +39,75 @@ function __getEventMethodsByName(that, name = "") {
   }
   return methods;
 }
-function __manageRef(that, name, elements, mode = "add") {
+function manageRef(that, name, elements, mode = "add") {
   const action = `${mode}EventListener`;
-  const methods = __getEventMethodsByName(that, name);
+  const methods = getEventMethodsByName(that, name);
   methods.forEach((method) => {
-    const event = __getEventNameByMethod(that, method, name);
+    const event = getEventNameByMethod(method, name);
     elements.forEach((element) => element[action](event, that.__refsHandler));
   });
 }
-function __manageChild(that, name, instance, mode = "add") {
+function manageChild(that, name, instance, mode = "add") {
   const action = mode === "add" ? "$on" : "$off";
-  const methods = __getEventMethodsByName(that, name);
+  const methods = getEventMethodsByName(that, name);
   methods.forEach((method) => {
-    const event = __getEventNameByMethod(that, method, name);
+    const event = getEventNameByMethod(method, name);
     instance[action](event, that.__childrenHandler);
   });
 }
-function __manageRootElement(that, mode = "add") {
+function manageRootElement(that, mode = "add") {
   const modeMethod = `${mode}EventListener`;
-  const methods = __getEventMethodsByName(that);
-  const { emits = [] } = that.__base.__config;
-  methods.forEach((method) => {
-    const event = __getEventNameByMethod(that, method);
-    const target = emits.includes(event) ? that.__base : that.__element;
+  const methods = getEventMethodsByName(that);
+  const { __base: base, __config: config } = that;
+  methods.map((method) => getEventNameByMethod(method)).filter((event) => eventIsDefinedInConfig(event, config) || eventIsNative(event, base.$el)).forEach((event) => {
+    const target = getEventTarget(base, event, config);
     target[modeMethod](event, that.__rootElementHandler);
   });
 }
 class EventsManager extends AbstractManager {
-  constructor(base) {
-    super(base);
-    __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());
-    __publicField(this, "__rootElementHandler", {
-      handleEvent: (event) => {
-        const normalizedEventName = normalizeName(event.type);
-        const method = `on${normalizedEventName}`;
+  __methodsCache = /* @__PURE__ */ new Map();
+  __rootElementHandler = {
+    handleEvent: (event) => {
+      const normalizedEventName = normalizeName(event.type);
+      const method = `on${normalizedEventName}`;
+      if (event instanceof CustomEvent && isArray(event.detail) && event.detail.length) {
+        this.__base[method](...event.detail, event);
+      } else {
         this.__base[method](event);
       }
-    });
-    __publicField(this, "__refsHandler", {
-      handleEvent: (event) => {
-        const ref = event.currentTarget;
-        const refName = normalizeRefName(ref.dataset.ref);
-        const normalizedRefName = normalizeName(refName);
-        const normalizedEventName = normalizeName(event.type);
-        const method = `on${normalizedRefName}${normalizedEventName}`;
-        let index = 0;
-        if (Array.isArray(this.__base.$refs[refName])) {
-          index = this.__base.$refs[refName].indexOf(ref);
-        }
-        this.__base[method](event, index);
+    }
+  };
+  __refsHandler = {
+    handleEvent: (event) => {
+      const ref = event.currentTarget;
+      const refName = normalizeRefName(ref.dataset.ref);
+      const normalizedRefName = normalizeName(refName);
+      const normalizedEventName = normalizeName(event.type);
+      const method = `on${normalizedRefName}${normalizedEventName}`;
+      let index = 0;
+      if (isArray(this.__base.$refs[refName])) {
+        index = this.__base.$refs[refName].indexOf(ref);
       }
-    });
-    __publicField(this, "__childrenHandler", {
-      handleEvent: (event) => {
-        const child = event.currentTarget;
-        let childName;
-        let index = 0;
-        const childrenManager = this.__base.$children;
-        childrenManager.registeredNames.find((name) => {
-          if (childrenManager[name].includes(child)) {
-            childName = name;
-            index = childrenManager[name].indexOf(child);
-            return true;
-          }
-          return false;
-        });
-        const normalizedRefName = normalizeName(childName);
-        const normalizedEventName = normalizeName(event.type);
-        const method = `on${normalizedRefName}${normalizedEventName}`;
-        const args = Array.isArray(event.detail) ? event.detail : [];
-        this.__base[method](...args, index, event);
-      }
-    });
+      this.__base[method](event, index);
+    }
+  };
+  __childrenHandler = {
+    handleEvent: (event) => {
+      const childrenManager = this.__base.$children;
+      const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
+        name: childName,
+        child: childrenManager[childName].find((instance) => instance === event.currentTarget || instance.$el === event.currentTarget)
+      })).find(({ child }) => child);
+      const normalizedChildName = normalizeName(name);
+      const normalizedEventName = normalizeName(event.type);
+      const method = `on${normalizedChildName}${normalizedEventName}`;
+      const index = childrenManager[name].indexOf(resolvedChild);
+      const args = isArray(event.detail) ? event.detail : [];
+      this.__base[method](...args, index, event);
+    }
+  };
+  constructor(base) {
+    super(base);
     this.__hideProperties([
       "__methodsCache",
       "__rootElementHandler",
@@ -123,22 +116,22 @@ class EventsManager extends AbstractManager {
     ]);
   }
   bindRef(name, elements) {
-    __manageRef(this, name, elements);
+    manageRef(this, name, elements);
   }
   unbindRef(name, elements) {
-    __manageRef(this, name, elements, "remove");
+    manageRef(this, name, elements, "remove");
   }
   bindChild(name, instance) {
-    __manageChild(this, name, instance);
+    manageChild(this, name, instance);
   }
   unbindChild(name, instance) {
-    __manageChild(this, name, instance, "remove");
+    manageChild(this, name, instance, "remove");
   }
   bindRootElement() {
-    __manageRootElement(this);
+    manageRootElement(this);
   }
   unbindRootElement() {
-    __manageRootElement(this, "remove");
+    manageRootElement(this, "remove");
   }
 }
 export {

package/Base/managers/OptionsManager.cjs

@@ -4,7 +4,6 @@ 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 });
@@ -19,10 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 };
 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/OptionsManager.js
 var OptionsManager_exports = {};
@@ -33,7 +28,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 +37,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;
@@ -56,13 +48,18 @@ function __getPropertyName(name, prefix = "") {
   return propertyName;
 }
 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.`);
+  config.default = config.default ?? __defaultValues[config.type.name];
+  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: () => {
@@ -75,23 +72,22 @@ function __register(that, name, config) {
   });
 }
 var OptionsManager = class extends import_AbstractManager.default {
+  __values = {};
+  name = "Base";
+  debug = false;
+  log = false;
   constructor(base) {
-    var _a, _b;
     super(base);
-    __publicField(this, "__values", {});
-    __publicField(this, "name", "Base");
-    __publicField(this, "debug", false);
-    __publicField(this, "log", false);
     this.__hideProperties(["__values", "__defaultValues"]);
     const schema = this.__config.options || {};
     this.name = this.__config.name;
     schema.debug = {
       type: Boolean,
-      default: (_a = this.__config.debug) != null ? _a : false
+      default: this.__config.debug ?? false
     };
     schema.log = {
       type: Boolean,
-      default: (_b = this.__config.log) != null ? _b : false
+      default: this.__config.log ?? false
     };
     Object.entries(schema).forEach(([name, config]) => {
       __register(this, name, types.has(config) ? { type: config } : config);
@@ -100,11 +96,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 +113,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 +126,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

@@ -1,12 +1,6 @@
-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 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 +9,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;
@@ -29,13 +20,18 @@ function __getPropertyName(name, prefix = "") {
   return propertyName;
 }
 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.`);
+  config.default = config.default ?? __defaultValues[config.type.name];
+  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: () => {
@@ -48,23 +44,22 @@ function __register(that, name, config) {
   });
 }
 class OptionsManager extends AbstractManager {
+  __values = {};
+  name = "Base";
+  debug = false;
+  log = false;
   constructor(base) {
-    var _a, _b;
     super(base);
-    __publicField(this, "__values", {});
-    __publicField(this, "name", "Base");
-    __publicField(this, "debug", false);
-    __publicField(this, "log", false);
     this.__hideProperties(["__values", "__defaultValues"]);
     const schema = this.__config.options || {};
     this.name = this.__config.name;
     schema.debug = {
       type: Boolean,
-      default: (_a = this.__config.debug) != null ? _a : false
+      default: this.__config.debug ?? false
     };
     schema.log = {
       type: Boolean,
-      default: (_b = this.__config.log) != null ? _b : false
+      default: this.__config.log ?? false
     };
     Object.entries(schema).forEach(([name, config]) => {
       __register(this, name, types.has(config) ? { type: config } : config);
@@ -73,11 +68,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 +85,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 +98,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: