@studiometa/js-toolkit 2.3.0 → 2.4.2

package/Base/managers/ChildrenManager.js

@@ -1,7 +1,15 @@
+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 AbstractManager from "./AbstractManager.js";
 import { getComponentElements } from "../utils.js";
 function __getChild(that, el, ComponentClass, name) {
-  const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
+  const asyncComponentPromise = that.__asyncComponentPromises.get(
+    ComponentClass
+  );
   if ("$isBase" in ComponentClass || asyncComponentPromise && asyncComponentPromise.status === "resolved") {
     let ctor = ComponentClass;
     if (asyncComponentPromise) {
@@ -23,7 +31,8 @@ function __getChild(that, el, ComponentClass, name) {
     });
   }
   return promise.then((module) => {
-    const ctor = module.default ?? module;
+    var _a;
+    const ctor = (_a = module.default) != null ? _a : module;
     that.__asyncComponentPromises.set(ComponentClass, {
       promise,
       status: "resolved",
@@ -69,12 +78,17 @@ function __triggerHookForAll(that, hook) {
   });
 }
 class ChildrenManager extends AbstractManager {
-  __asyncComponentPromises = /* @__PURE__ */ new WeakMap();
+  constructor() {
+    super(...arguments);
+    __publicField(this, "__asyncComponentPromises", /* @__PURE__ */ new WeakMap());
+  }
   get registeredNames() {
     return Object.keys(this).filter((key) => !key.startsWith("__"));
   }
   registerAll() {
-    Object.entries(this.__config.components).forEach(([name, component]) => __register(this, name, component));
+    Object.entries(this.__config.components).forEach(
+      ([name, component]) => __register(this, name, component)
+    );
   }
   mountAll() {
     __triggerHookForAll(this, "$mount");

package/Base/managers/EventsManager.cjs

@@ -4,6 +4,7 @@ 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 });
@@ -16,8 +17,15 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 __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 = {};
@@ -35,7 +43,10 @@ var import_RefsManager = require("./RefsManager.cjs");
 var names = /* @__PURE__ */ new Map();
 function normalizeName(name) {
   if (!names.has(name)) {
-    names.set(name, name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim());
+    names.set(
+      name,
+      name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim()
+    );
   }
   return names.get(name);
 }
@@ -63,7 +74,12 @@ function getEventMethodsByName(that, name = "") {
   const key = regex.toString();
   let methods = that.__methodsCache.get(key);
   if (!methods) {
-    methods = Array.from((0, import_getAllProperties.default)(that.__base, [], (method) => regex.test(method)).reduce((set, [method]) => set.add(method), /* @__PURE__ */ new Set()));
+    methods = Array.from(
+      (0, import_getAllProperties.default)(that.__base, [], (method) => regex.test(method)).reduce(
+        (set, [method]) => set.add(method),
+        /* @__PURE__ */ new Set()
+      )
+    );
     that.__methodsCache.set(key, methods);
   }
   return methods;
@@ -94,49 +110,51 @@ function manageRootElement(that, mode = "add") {
   });
 }
 var EventsManager = class extends import_AbstractManager.default {
-  __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);
-      }
-    }
-  };
-  __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);
-      }
-      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);
+    __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());
+    __publicField(this, "__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 ((0, import_utils.isArray)(this.__base.$refs[refName])) {
+          index = this.__base.$refs[refName].indexOf(ref);
+        }
+        this.__base[method](event, index);
+      }
+    });
+    __publicField(this, "__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);
+      }
+    });
     this.__hideProperties([
       "__methodsCache",
       "__rootElementHandler",

package/Base/managers/EventsManager.d.ts

@@ -83,7 +83,7 @@ export default class EventsManager extends AbstractManager {
      *   A base instance.
      * @returns {void}
      */
-    bindChild(name: string, instance: Base): void;
+    bindChild(name: string, instance: import("../index.js").default<any>): void;
     /**
      * Unbind event methods to the given child instance.
      *
@@ -93,7 +93,7 @@ export default class EventsManager extends AbstractManager {
      *   A base instance.
      * @returns {void}
      */
-    unbindChild(name: string, instance: Base): void;
+    unbindChild(name: string, instance: import("../index.js").default<any>): void;
     /**
      * Bind event methods on the root element.
      *
@@ -107,6 +107,6 @@ export default class EventsManager extends AbstractManager {
      */
     unbindRootElement(): void;
 }
-export type Base = import('../index.js').default;
+export type Base = import("../index.js").default<any>;
 export type ChildrenManager = import('./ChildrenManager.js').default;
 import AbstractManager from "./AbstractManager.js";

package/Base/managers/EventsManager.js

@@ -1,3 +1,9 @@
+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";
@@ -6,7 +12,10 @@ import { normalizeRefName } from "./RefsManager.js";
 const names = /* @__PURE__ */ new Map();
 function normalizeName(name) {
   if (!names.has(name)) {
-    names.set(name, name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim());
+    names.set(
+      name,
+      name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim()
+    );
   }
   return names.get(name);
 }
@@ -34,7 +43,12 @@ function getEventMethodsByName(that, name = "") {
   const key = regex.toString();
   let methods = that.__methodsCache.get(key);
   if (!methods) {
-    methods = Array.from(getAllProperties(that.__base, [], (method) => regex.test(method)).reduce((set, [method]) => set.add(method), /* @__PURE__ */ new Set()));
+    methods = Array.from(
+      getAllProperties(that.__base, [], (method) => regex.test(method)).reduce(
+        (set, [method]) => set.add(method),
+        /* @__PURE__ */ new Set()
+      )
+    );
     that.__methodsCache.set(key, methods);
   }
   return methods;
@@ -65,49 +79,51 @@ function manageRootElement(that, mode = "add") {
   });
 }
 class EventsManager extends AbstractManager {
-  __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);
-      }
-    }
-  };
-  __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);
-      }
-      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);
+    __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());
+    __publicField(this, "__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 (isArray(this.__base.$refs[refName])) {
+          index = this.__base.$refs[refName].indexOf(ref);
+        }
+        this.__base[method](event, index);
+      }
+    });
+    __publicField(this, "__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);
+      }
+    });
     this.__hideProperties([
       "__methodsCache",
       "__rootElementHandler",

package/Base/managers/OptionsManager.cjs

@@ -4,6 +4,7 @@ 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 });
@@ -16,8 +17,15 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 __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 = {};
@@ -48,16 +56,21 @@ function __getPropertyName(name, prefix = "") {
   return propertyName;
 }
 function __register(that, name, config) {
+  var _a;
   if (!types.has(config.type)) {
     if (import_utils.isDev) {
-      throw new Error(`The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`);
+      throw new Error(
+        `The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`
+      );
     }
     return;
   }
-  config.default = config.default ?? __defaultValues[config.type.name];
+  config.default = (_a = config.default) != null ? _a : __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.`);
+      throw new Error(
+        `The default value for options of type "${config.type.name}" must be returned by a function.`
+      );
     }
     return;
   }
@@ -72,25 +85,30 @@ 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: this.__config.debug ?? false
+      default: (_a = this.__config.debug) != null ? _a : false
     };
     schema.log = {
       type: Boolean,
-      default: this.__config.log ?? false
+      default: (_b = this.__config.log) != null ? _b : false
     };
     Object.entries(schema).forEach(([name, config]) => {
-      __register(this, name, types.has(config) ? { type: config } : config);
+      __register(
+        this,
+        name,
+        types.has(config) ? { type: config } : config
+      );
     });
   }
   get(name, config) {
@@ -128,7 +146,9 @@ var OptionsManager = class extends import_AbstractManager.default {
     if (value.constructor.name !== 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}"`);
+        throw new TypeError(
+          `The "${val}" value for the "${name}" option must be of type "${type.name}"`
+        );
       }
       return;
     }

package/Base/managers/OptionsManager.d.ts

@@ -52,7 +52,7 @@ export default class OptionsManager extends AbstractManager {
     set(name: string, value: any, config: OptionObject): void;
 }
 export type DeepmergeOptions = import('deepmerge').Options;
-export type Base = import('../index.js').default;
+export type Base = import("../index.js").default<any>;
 export type BaseConfig = import('../index.js').BaseConfig;
 export type OptionType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
 export type ArrayOption = {
@@ -79,7 +79,7 @@ export type BooleanOption = {
 };
 export type OptionObject = ArrayOption | ObjectOption | StringOption | NumberOption | BooleanOption;
 export type OptionsSchema = {
-    [name: string]: OptionType | OptionObject;
+    [name: string]: OptionObject | OptionType;
 };
 export type OptionsInterface = {
     [optionName: string]: any;

package/Base/managers/OptionsManager.js

@@ -1,3 +1,9 @@
+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 { isDev, isFunction, isDefined, isBoolean, isArray, isObject } from "../../utils/index.js";
@@ -20,16 +26,21 @@ function __getPropertyName(name, prefix = "") {
   return propertyName;
 }
 function __register(that, name, config) {
+  var _a;
   if (!types.has(config.type)) {
     if (isDev) {
-      throw new Error(`The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`);
+      throw new Error(
+        `The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`
+      );
     }
     return;
   }
-  config.default = config.default ?? __defaultValues[config.type.name];
+  config.default = (_a = config.default) != null ? _a : __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.`);
+      throw new Error(
+        `The default value for options of type "${config.type.name}" must be returned by a function.`
+      );
     }
     return;
   }
@@ -44,25 +55,30 @@ 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: this.__config.debug ?? false
+      default: (_a = this.__config.debug) != null ? _a : false
     };
     schema.log = {
       type: Boolean,
-      default: this.__config.log ?? false
+      default: (_b = this.__config.log) != null ? _b : false
     };
     Object.entries(schema).forEach(([name, config]) => {
-      __register(this, name, types.has(config) ? { type: config } : config);
+      __register(
+        this,
+        name,
+        types.has(config) ? { type: config } : config
+      );
     });
   }
   get(name, config) {
@@ -100,7 +116,9 @@ class OptionsManager extends AbstractManager {
     if (value.constructor.name !== 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}"`);
+        throw new TypeError(
+          `The "${val}" value for the "${name}" option must be of type "${type.name}"`
+        );
       }
       return;
     }

package/Base/managers/RefsManager.cjs

@@ -16,7 +16,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 __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/Base/managers/RefsManager.js
@@ -41,13 +44,23 @@ function __filterRefsBelongingToInstance(that, ref) {
 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));
+  const refs = Array.from(that.__element.querySelectorAll(`[data-ref="${refName}"]`)).filter(
+    (ref) => __filterRefsBelongingToInstance(that, ref)
+  );
   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?");
+    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 && !(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?`);
+      console.warn(
+        `[${that.__base.$options.name}]`,
+        `The "${refName}" ref is missing.`,
+        `Is there an \`[data-ref="${refName}"]\` element in the component's scope?`
+      );
     }
     return;
   }
@@ -65,7 +78,8 @@ function __unregister(that, refName) {
 }
 var RefsManager = class extends import_AbstractManager.default {
   get __refs() {
-    return this.__config.refs ?? [];
+    var _a;
+    return (_a = this.__config.refs) != null ? _a : [];
   }
   registerAll() {
     this.__refs.forEach((refName) => __register(this, refName));

package/Base/managers/RefsManager.js

@@ -13,13 +13,23 @@ function __filterRefsBelongingToInstance(that, ref) {
 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));
+  const refs = Array.from(that.__element.querySelectorAll(`[data-ref="${refName}"]`)).filter(
+    (ref) => __filterRefsBelongingToInstance(that, ref)
+  );
   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?");
+    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 && !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?`);
+      console.warn(
+        `[${that.__base.$options.name}]`,
+        `The "${refName}" ref is missing.`,
+        `Is there an \`[data-ref="${refName}"]\` element in the component's scope?`
+      );
     }
     return;
   }
@@ -37,7 +47,8 @@ function __unregister(that, refName) {
 }
 class RefsManager extends AbstractManager {
   get __refs() {
-    return this.__config.refs ?? [];
+    var _a;
+    return (_a = this.__config.refs) != null ? _a : [];
   }
   registerAll() {
     this.__refs.forEach((refName) => __register(this, refName));

package/Base/managers/ResponsiveOptionsManager.cjs

@@ -16,7 +16,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 __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/Base/managers/ResponsiveOptionsManager.js