@studiometa/js-toolkit 2.5.0 → 2.6.0

package/Base/index.cjs

@@ -1,8 +1,6 @@
-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) => {
@@ -17,10 +15,6 @@ 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -34,11 +28,11 @@ __export(Base_exports, {
 });
 module.exports = __toCommonJS(Base_exports);
 var import_utils = require("./utils.cjs");
-var import_ChildrenManager = __toESM(require("./managers/ChildrenManager.cjs"), 1);
-var import_RefsManager = __toESM(require("./managers/RefsManager.cjs"), 1);
-var import_ServicesManager = __toESM(require("./managers/ServicesManager.cjs"), 1);
-var import_EventsManager = __toESM(require("./managers/EventsManager.cjs"), 1);
-var import_OptionsManager = __toESM(require("./managers/OptionsManager.cjs"), 1);
+var import_ChildrenManager = require("./managers/ChildrenManager.cjs");
+var import_RefsManager = require("./managers/RefsManager.cjs");
+var import_ServicesManager = require("./managers/ServicesManager.cjs");
+var import_EventsManager = require("./managers/EventsManager.cjs");
+var import_OptionsManager = require("./managers/OptionsManager.cjs");
 var import_utils2 = require("../utils/index.cjs");
 var id = 0;
 function createAndTestManagers(instance) {
@@ -46,27 +40,27 @@ function createAndTestManagers(instance) {
     {
       prop: "__options",
       constructorName: "OptionsManager",
-      constructor: import_OptionsManager.default
+      constructor: import_OptionsManager.OptionsManager
     },
     {
       prop: "__services",
       constructorName: "ServicesManager",
-      constructor: import_ServicesManager.default
+      constructor: import_ServicesManager.ServicesManager
     },
     {
       prop: "__events",
       constructorName: "EventsManager",
-      constructor: import_EventsManager.default
+      constructor: import_EventsManager.EventsManager
     },
     {
       prop: "__refs",
       constructorName: "RefsManager",
-      constructor: import_RefsManager.default
+      constructor: import_RefsManager.RefsManager
     },
     {
       prop: "__children",
       constructorName: "ChildrenManager",
-      constructor: import_ChildrenManager.default
+      constructor: import_ChildrenManager.ChildrenManager
     }
   ].forEach(({ prop, constructorName, constructor }) => {
     instance[prop] = new instance.__managers[constructorName](instance);
@@ -168,11 +162,11 @@ var Base = class extends EventTarget {
   }
   get __managers() {
     return {
-      ChildrenManager: import_ChildrenManager.default,
-      EventsManager: import_EventsManager.default,
-      OptionsManager: import_OptionsManager.default,
-      RefsManager: import_RefsManager.default,
-      ServicesManager: import_ServicesManager.default
+      ChildrenManager: import_ChildrenManager.ChildrenManager,
+      EventsManager: import_EventsManager.EventsManager,
+      OptionsManager: import_OptionsManager.OptionsManager,
+      RefsManager: import_RefsManager.RefsManager,
+      ServicesManager: import_ServicesManager.ServicesManager
     };
   }
   __callMethod(method, ...args) {

package/Base/index.d.ts

@@ -1,8 +1,8 @@
-import ChildrenManager from './managers/ChildrenManager.js';
-import RefsManager from './managers/RefsManager.js';
-import ServicesManager from './managers/ServicesManager.js';
-import EventsManager from './managers/EventsManager.js';
-import OptionsManager from './managers/OptionsManager.js';
+import { ChildrenManager } from './managers/ChildrenManager.js';
+import { RefsManager } from './managers/RefsManager.js';
+import { ServicesManager } from './managers/ServicesManager.js';
+import { EventsManager } from './managers/EventsManager.js';
+import { OptionsManager } from './managers/OptionsManager.js';
 export declare type BaseEl = HTMLElement & {
     __base__?: WeakMap<BaseConstructor, Base | 'terminated'>;
 };

package/Base/index.js

@@ -5,11 +5,11 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import { getComponentElements, getEventTarget } from "./utils.js";
-import ChildrenManager from "./managers/ChildrenManager.js";
-import RefsManager from "./managers/RefsManager.js";
-import ServicesManager from "./managers/ServicesManager.js";
-import EventsManager from "./managers/EventsManager.js";
-import OptionsManager from "./managers/OptionsManager.js";
+import { ChildrenManager } from "./managers/ChildrenManager.js";
+import { RefsManager } from "./managers/RefsManager.js";
+import { ServicesManager } from "./managers/ServicesManager.js";
+import { EventsManager } from "./managers/EventsManager.js";
+import { OptionsManager } from "./managers/OptionsManager.js";
 import { noop, isDev, isFunction, isArray } from "../utils/index.js";
 let id = 0;
 function createAndTestManagers(instance) {

package/Base/managers/AbstractManager.cjs

@@ -21,10 +21,10 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/Base/managers/AbstractManager.js
+// packages/js-toolkit/Base/managers/AbstractManager.ts
 var AbstractManager_exports = {};
 __export(AbstractManager_exports, {
-  default: () => AbstractManager
+  AbstractManager: () => AbstractManager
 });
 module.exports = __toCommonJS(AbstractManager_exports);
 var AbstractManager = class {

package/Base/managers/AbstractManager.d.ts

@@ -1,37 +1,30 @@
-/**
- * @typedef {import('../index.js').Base} Base
- * @typedef {import('../index.js').BaseConfig} BaseConfig
- * @typedef {import('./EventsManager.js').default} EventsManager
- */
+import type { Base } from '../index.js';
 /**
  * AbstractManager class.
  */
-export default class AbstractManager {
-    /**
-     * Class constructor.
-     *
-     * @param   {Base} base
-     */
-    constructor(base: Base);
+export declare class AbstractManager {
     /**
-     * @type {Base}
+     * Base instance.
      */
     __base: Base;
     /**
      * Get the base instance root element.
-     * @returns {HTMLElement}
      */
-    get __element(): HTMLElement;
+    get __element(): HTMLElement & {
+        __base__?: WeakMap<import("../index.js").BaseConstructor<Base<import("../index.js").BaseProps>>, Base<import("../index.js").BaseProps> | "terminated">;
+    };
     /**
      * Get the base instance config.
-     * @returns {BaseConfig}
      */
     get __config(): import("../index.js").BaseConfig;
     /**
      * Get the events manager.
-     * @returns {EventsManager}
      */
-    get __eventsManager(): import("./EventsManager.js").default;
+    get __eventsManager(): import("./EventsManager.js").EventsManager;
+    /**
+     * Class constructor.
+     */
+    constructor(base: Base);
     /**
      * Prevent a list of properties from being enumerable and writable.
      * @param   {string[]} properties
@@ -39,6 +32,3 @@ export default class AbstractManager {
      */
     __hideProperties(properties: string[]): void;
 }
-export type Base = import('../index.js').Base;
-export type BaseConfig = import('../index.js').BaseConfig;
-export type EventsManager = import('./EventsManager.js').default;

package/Base/managers/AbstractManager.js

@@ -36,5 +36,5 @@ class AbstractManager {
   }
 }
 export {
-  AbstractManager as default
+  AbstractManager
 };

package/Base/managers/ChildrenManager.cjs

@@ -1,8 +1,6 @@
-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) => {
@@ -17,10 +15,6 @@ 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -30,10 +24,10 @@ var __publicField = (obj, key, value) => {
 // packages/js-toolkit/Base/managers/ChildrenManager.ts
 var ChildrenManager_exports = {};
 __export(ChildrenManager_exports, {
-  default: () => ChildrenManager
+  ChildrenManager: () => ChildrenManager
 });
 module.exports = __toCommonJS(ChildrenManager_exports);
-var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+var import_AbstractManager = require("./AbstractManager.cjs");
 var import_utils = require("../utils.cjs");
 function __getChild(that, el, ComponentClass, name) {
   const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
@@ -104,7 +98,7 @@ function __triggerHookForAll(that, hook) {
     });
   });
 }
-var ChildrenManager = class extends import_AbstractManager.default {
+var ChildrenManager = class extends import_AbstractManager.AbstractManager {
   constructor() {
     super(...arguments);
     __publicField(this, "__asyncComponentPromises", /* @__PURE__ */ new WeakMap());

package/Base/managers/ChildrenManager.d.ts

@@ -1,9 +1,9 @@
 import type { BaseConstructor, BaseAsyncConstructor } from '../index.js';
-import AbstractManager from './AbstractManager.js';
+import { AbstractManager } from './AbstractManager.js';
 /**
  * Children manager.
  */
-export default class ChildrenManager extends AbstractManager {
+export declare class ChildrenManager extends AbstractManager {
     /**
      * Store async component promises to avoid calling them multiple times and
      * waiting for them when they are already resolved.

package/Base/managers/ChildrenManager.js

@@ -4,7 +4,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import AbstractManager from "./AbstractManager.js";
+import { AbstractManager } from "./AbstractManager.js";
 import { getComponentElements } from "../utils.js";
 function __getChild(that, el, ComponentClass, name) {
   const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
@@ -99,5 +99,5 @@ class ChildrenManager extends AbstractManager {
   }
 }
 export {
-  ChildrenManager as default
+  ChildrenManager
 };

package/Base/managers/EventsManager.cjs

@@ -30,7 +30,7 @@ var __publicField = (obj, key, value) => {
 // packages/js-toolkit/Base/managers/EventsManager.ts
 var EventsManager_exports = {};
 __export(EventsManager_exports, {
-  default: () => EventsManager,
+  EventsManager: () => EventsManager,
   normalizeEventName: () => normalizeEventName,
   normalizeName: () => normalizeName
 });
@@ -38,7 +38,7 @@ 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_AbstractManager = require("./AbstractManager.cjs");
 var import_RefsManager = require("./RefsManager.cjs");
 var names = /* @__PURE__ */ new Map();
 var normalizeRegex1 = /[A-Z]([A-Z].*)/g;
@@ -133,7 +133,7 @@ function manageRootElement(that, mode = "add") {
     }
   });
 }
-var EventsManager = class extends import_AbstractManager.default {
+var EventsManager = class extends import_AbstractManager.AbstractManager {
   constructor(base) {
     super(base);
     __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());

package/Base/managers/EventsManager.d.ts

@@ -1,5 +1,5 @@
 import type { Base } from '../index.js';
-import AbstractManager from './AbstractManager.js';
+import { AbstractManager } from './AbstractManager.js';
 /**
  * Normalize the given name to PascalCase, such as:
  *
@@ -33,7 +33,7 @@ export declare function normalizeEventName(name: string): string;
  * @todo Prevent binding of `onChildOrRefEvent` to the root element
  * @todo Use event delegation?
  */
-export default class EventsManager extends AbstractManager {
+export declare class EventsManager extends AbstractManager {
     __methodsCache: Map<string, string[]>;
     /**
      * Event listener object for the root element.

package/Base/managers/EventsManager.js

@@ -7,7 +7,7 @@ var __publicField = (obj, key, 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 { AbstractManager } from "./AbstractManager.js";
 import { normalizeRefName } from "./RefsManager.js";
 const names = /* @__PURE__ */ new Map();
 const normalizeRegex1 = /[A-Z]([A-Z].*)/g;
@@ -191,7 +191,7 @@ class EventsManager extends AbstractManager {
   }
 }
 export {
-  EventsManager as default,
+  EventsManager,
   normalizeEventName,
   normalizeName
 };

package/Base/managers/OptionsManager.cjs

@@ -27,15 +27,15 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/Base/managers/OptionsManager.js
+// packages/js-toolkit/Base/managers/OptionsManager.ts
 var OptionsManager_exports = {};
 __export(OptionsManager_exports, {
-  __getPropertyName: () => __getPropertyName,
-  default: () => OptionsManager
+  OptionsManager: () => OptionsManager,
+  __getPropertyName: () => __getPropertyName
 });
 module.exports = __toCommonJS(OptionsManager_exports);
 var import_deepmerge = __toESM(require("deepmerge"), 1);
-var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+var import_AbstractManager = require("./AbstractManager.cjs");
 var import_utils = require("../../utils/index.cjs");
 var types = /* @__PURE__ */ new Set([String, Number, Boolean, Array, Object]);
 var __defaultValues = {
@@ -75,16 +75,14 @@ function __register(that, name, config) {
     return;
   }
   Object.defineProperty(that, name, {
-    get: () => {
-      return that.get(name, config);
-    },
+    get: () => that.get(name, config),
     set: (value) => {
       that.set(name, value, config);
     },
     enumerable: true
   });
 }
-var OptionsManager = class extends import_AbstractManager.default {
+var OptionsManager = class extends import_AbstractManager.AbstractManager {
   constructor(base) {
     var _a, _b;
     super(base);

package/Base/managers/OptionsManager.d.ts

@@ -1,87 +1,74 @@
+import type { Options as DeepmergeOptions } from 'deepmerge';
+import { AbstractManager } from './AbstractManager.js';
+import type { Base } from '../index.js';
+declare type OptionType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
+declare type ArrayOption = {
+    type: ArrayConstructor;
+    default?: () => unknown[];
+    merge?: boolean | DeepmergeOptions;
+};
+declare type ObjectOption = {
+    type: ObjectConstructor;
+    default?: () => unknown;
+    merge?: boolean | DeepmergeOptions;
+};
+declare type StringOption = {
+    type: StringConstructor;
+    default?: string;
+};
+declare type NumberOption = {
+    type: NumberConstructor;
+    default?: number;
+};
+declare type BooleanOption = {
+    type: BooleanConstructor;
+    default?: boolean;
+};
+export declare type OptionObject = ArrayOption | ObjectOption | StringOption | NumberOption | BooleanOption;
+export declare type OptionsSchema = {
+    [name: string]: OptionType | OptionObject;
+};
+export declare type OptionsInterface = {
+    [optionName: string]: unknown;
+};
 /**
  * Get a property name.
- *
- * @param  {string} name
- * @param  {string} [prefix]
- * @returns {string}
- * @protected
  */
-export function __getPropertyName(name: string, prefix?: string): string;
+export declare function __getPropertyName(name: string, prefix?: string): string;
 /**
  * Class options to manage options as data attributes on an HTML element.
  *
  * @todo Use `MutationObserver` to update values? Might be more performant.
  */
-export default class OptionsManager extends AbstractManager {
+export declare class OptionsManager extends AbstractManager {
     /**
      * An object to store Array and Object values for reference.
-     * @type {Object}
      * @private
      */
-    private __values;
+    __values: {};
     /**
      * Default value for the name property.
-     * @type {string}
      */
     name: string;
     /**
      * Default value for the debug property.
-     * @type {boolean}
      */
     debug: boolean;
     /**
      * Default value for the log property.
-     * @type {boolean}
      */
     log: boolean;
+    /**
+     * Class constructor.
+     */
+    constructor(base: Base);
     /**
      * Get an option value.
-     *
-     * @param   {string} name The option name.
-     * @param   {OptionObject} config The option config.
-     * @returns {any}
      */
     get(name: string, config: OptionObject): any;
     /**
      * Set an option value.
-     *
-     * @param {string} name The option name.
-     * @param {any} value The new value for this option.
-     * @param {OptionObject} config The option config.
      */
-    set(name: string, value: any, config: OptionObject): void;
+    set(name: string, value: unknown, config: OptionObject): void;
 }
-export type DeepmergeOptions = import('deepmerge').Options;
-export type Base = import('../index.js').Base;
-export type BaseConfig = import('../index.js').BaseConfig;
-export type OptionType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
-export type ArrayOption = {
-    type: ArrayConstructor;
-    default?: () => any[];
-    merge?: boolean;
-};
-export type ObjectOption = {
-    type: ObjectConstructor;
-    default?: () => any;
-    merge?: boolean;
-};
-export type StringOption = {
-    type: StringConstructor;
-    default?: string;
-};
-export type NumberOption = {
-    type: NumberConstructor;
-    default?: number;
-};
-export type BooleanOption = {
-    type: BooleanConstructor;
-    default?: boolean;
-};
-export type OptionObject = ArrayOption | ObjectOption | StringOption | NumberOption | BooleanOption;
-export type OptionsSchema = {
-    [name: string]: OptionObject | OptionType;
-};
-export type OptionsInterface = {
-    [optionName: string]: any;
-};
-import AbstractManager from "./AbstractManager.js";
+export {};

package/Base/managers/OptionsManager.js

@@ -5,7 +5,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import deepmerge from "deepmerge";
-import AbstractManager from "./AbstractManager.js";
+import { AbstractManager } from "./AbstractManager.js";
 import { isDev, isFunction, isDefined, isBoolean, isArray, isObject } from "../../utils/index.js";
 const types = /* @__PURE__ */ new Set([String, Number, Boolean, Array, Object]);
 const __defaultValues = {
@@ -45,9 +45,7 @@ function __register(that, name, config) {
     return;
   }
   Object.defineProperty(that, name, {
-    get: () => {
-      return that.get(name, config);
-    },
+    get: () => that.get(name, config),
     set: (value) => {
       that.set(name, value, config);
     },
@@ -147,6 +145,6 @@ class OptionsManager extends AbstractManager {
   }
 }
 export {
-  __getPropertyName,
-  OptionsManager as default
+  OptionsManager,
+  __getPropertyName
 };

package/Base/managers/RefsManager.cjs

@@ -1,8 +1,6 @@
-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)
@@ -16,23 +14,20 @@ 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/js-toolkit/Base/managers/RefsManager.js
+// packages/js-toolkit/Base/managers/RefsManager.ts
 var RefsManager_exports = {};
 __export(RefsManager_exports, {
-  default: () => RefsManager,
+  RefsManager: () => RefsManager,
   normalizeRefName: () => normalizeRefName
 });
 module.exports = __toCommonJS(RefsManager_exports);
-var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+var import_AbstractManager = require("./AbstractManager.cjs");
 var import_utils = require("../../utils/index.cjs");
+var NORMALIZE_REF_NAME_REGEX = /\[\]$/;
 function normalizeRefName(name) {
-  return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
+  return name.endsWith("[]") ? name.replace(NORMALIZE_REF_NAME_REGEX, "") : name;
 }
 function __filterRefsBelongingToInstance(that, ref) {
   let ancestor = ref.parentElement;
@@ -44,9 +39,9 @@ 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}]`,
@@ -76,7 +71,7 @@ function __unregister(that, refName) {
   const refs = (0, import_utils.isArray)(that[propName]) ? that[propName] : [that[propName]];
   that.__eventsManager.unbindRef(refName, refs);
 }
-var RefsManager = class extends import_AbstractManager.default {
+var RefsManager = class extends import_AbstractManager.AbstractManager {
   get __refs() {
     var _a;
     return (_a = this.__config.refs) != null ? _a : [];

package/Base/managers/RefsManager.d.ts

@@ -1,32 +1,24 @@
+import { AbstractManager } from './AbstractManager.js';
 /**
  * Normalize the name of ref.
- *
- * @param {string} name The original name.
- * @returns {string}     The normalized name.
  */
-export function normalizeRefName(name: string): string;
+export declare function normalizeRefName(name: string): string;
 /**
  * Refs Manager
  *
  * @todo Use `MutationObserver` to automatically update refs?
  */
-export default class RefsManager extends AbstractManager {
+export declare class RefsManager extends AbstractManager {
     /**
      * Get refs configuration.
-     * @returns {string[]}
      */
     get __refs(): string[];
     /**
      * Register all refs.
-     *
-     * @returns {void}
      */
     registerAll(): void;
     /**
      * Unregister all refs.
-     *
-     * @returns {void}
      */
     unregisterAll(): void;
 }
-import AbstractManager from "./AbstractManager.js";

package/Base/managers/RefsManager.js

@@ -1,7 +1,8 @@
-import AbstractManager from "./AbstractManager.js";
+import { AbstractManager } from "./AbstractManager.js";
 import { isDev, isArray, isDefined } from "../../utils/index.js";
+const NORMALIZE_REF_NAME_REGEX = /\[\]$/;
 function normalizeRefName(name) {
-  return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
+  return name.endsWith("[]") ? name.replace(NORMALIZE_REF_NAME_REGEX, "") : name;
 }
 function __filterRefsBelongingToInstance(that, ref) {
   let ancestor = ref.parentElement;
@@ -13,9 +14,9 @@ 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}]`,
@@ -58,6 +59,6 @@ class RefsManager extends AbstractManager {
   }
 }
 export {
-  RefsManager as default,
+  RefsManager,
   normalizeRefName
 };