@studiometa/js-toolkit 2.0.1 → 2.2.0-alpha.1

package/Base/managers/EventsManager.d.ts

@@ -2,62 +2,44 @@
  * @typedef {import('../index.js').default} Base
  * @typedef {import('./ChildrenManager.js').default} ChildrenManager
  */
+/**
+ * Normalize the given name to PascalCase, such as:
+ *
+ * ```
+ * sentence case          => SentenceCase
+ * lowercase              => Lowercase
+ * UPPERCASE              => Uppercase
+ * kebab-case             => KebabCase
+ * snake_case             => SnakeCase
+ * camelCase              => CamelCase
+ * PascalCase             => PascalCase
+ * .class-selector        => ClassSelector
+ * .bem__selector         => BemSelector
+ * __id-selector          => IdSelector
+ * .complex[class^ ="__"] => ComplexClass
+ * ```
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+export function normalizeName(name: string): string;
+/**
+ * Normalize the event names from PascalCase to kebab-case.
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+export function normalizeEventName(name: string): string;
 /**
  * Event management class.
  * @todo Prevent binding of `onChildOrRefEvent` to the root element
  * @todo Use event delegation?
  */
-export default class EventsManager {
-    /**
-     * Normalize the given name to PascalCase, such as:
-     *
-     * ```
-     * sentence case          => SentenceCase
-     * lowercase              => Lowercase
-     * UPPERCASE              => Uppercase
-     * kebab-case             => KebabCase
-     * snake_case             => SnakeCase
-     * camelCase              => CamelCase
-     * PascalCase             => PascalCase
-     * .class-selector        => ClassSelector
-     * .bem__selector         => BemSelector
-     * __id-selector          => IdSelector
-     * .complex[class^ ="__"] => ComplexClass
-     * ```
-     *
-     * @param {string} name
-     * @returns {string}
-     */
-    static normalizeName(name: string): string;
-    /**
-     * Normalize the event names from PascalCase to kebab-case.
-     *
-     * @param {string} name
-     * @returns {string}
-     */
-    static normalizeEventName(name: string): string;
-    /**
-     * Class constructor.
-     *
-     * @param {HTMLElement} rootElement
-     * @param {Base} base
-     */
-    constructor(rootElement: HTMLElement, base: Base);
-    /**
-     * @type {HTMLElement}
-     * @private
-     */
-    private __rootElement;
-    /**
-     * @type {Base}
-     * @private
-     */
-    private __base;
+export default class EventsManager extends AbstractManager {
     /**
      * @type {WeakMap}
-     * @private
      */
-    private __methodsCache;
+    __methodsCache: WeakMap<any, any>;
     /**
      * Event listener object for the root element.
      *
@@ -76,19 +58,6 @@ export default class EventsManager {
      * @type {EventListenerObject}
      */
     __childrenHandler: EventListenerObject;
-    /**
-     * Manage a ref event methods.
-     *
-     * @param  {string} name
-     *   The name of the ref.
-     * @param  {HTMLElement[]} elements
-     *   The elements of the ref.
-     * @param  {'add'|'remove'} [mode]
-     *   The action to perform: add or remove the event listeners.
-     * @returns {void}
-     * @private
-     */
-    private __manageRef;
     /**
      * Bind event methods to the given ref elements.
      *
@@ -109,19 +78,6 @@ export default class EventsManager {
      * @returns {void}
      */
     unbindRef(name: string, elements: HTMLElement[]): void;
-    /**
-     * Manage event methods to the given child instance.
-     *
-     * @param {string} name
-     *   The name of the ref.
-     * @param {Base} instance
-     *   A base instance.
-     * @param {'add'|'remove'} [mode]
-     *   The action to perform: add or remove the event listeners.
-     * @returns {void}
-     * @private
-     */
-    private __manageChild;
     /**
      * Bind event methods to the given child instance.
      *
@@ -142,15 +98,6 @@ export default class EventsManager {
      * @returns {void}
      */
     unbindChild(name: string, instance: Base): void;
-    /**
-     * Manage event methods on the root element.
-     *
-     * @param {'add'|'remove'} [mode]
-     *   The action to perform: add or remove the event listeners, defaults to 'add'.
-     * @returns {void}
-     * @private
-     */
-    private __manageRootElement;
     /**
      * Bind event methods on the root element.
      *
@@ -163,23 +110,7 @@ export default class EventsManager {
      * @returns {void}
      */
     unbindRootElement(): void;
-    /**
-     * Get the event name from the given method and its tied ref or children name.
-     *
-     * @param {string} method
-     * @param {string} name
-     * @returns {string}
-     * @private
-     */
-    private __getEventNameByMethod;
-    /**
-     * Get the base instance methods matching the `onSomething` pattern.
-     *
-     * @param {string} [name]
-     * @returns {string[]}
-     * @private
-     */
-    private __getEventMethodsByName;
 }
 export type Base = import('../index.js').default;
 export type ChildrenManager = import('./ChildrenManager.js').default;
+import AbstractManager from "./AbstractManager.js";

package/Base/managers/EventsManager.js

@@ -5,15 +5,64 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import getAllProperties from "../../utils/object/getAllProperties.js";
-import RefsManager from "./RefsManager.js";
-class EventsManager {
-  constructor(rootElement, base) {
-    __publicField(this, "__rootElement");
-    __publicField(this, "__base");
+import AbstractManager from "./AbstractManager.js";
+import { normalizeRefName } from "./RefsManager.js";
+function normalizeName(name) {
+  return 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();
+}
+function normalizeEventName(name) {
+  return name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, "");
+}
+function __getEventNameByMethod(that, method, name = "") {
+  const normalizedName = normalizeName(name);
+  const regex = new RegExp(`^on${normalizedName}([A-Z].*)$`);
+  const [, event] = method.match(regex);
+  return normalizeEventName(event);
+}
+function __getEventMethodsByName(that, name = "") {
+  const normalizedName = normalizeName(name);
+  const regex = new RegExp(`^on${normalizedName}[A-Z].*$`);
+  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()));
+    that.__methodsCache.set(key, methods);
+  }
+  return methods;
+}
+function __manageRef(that, name, elements, mode = "add") {
+  const action = `${mode}EventListener`;
+  const methods = __getEventMethodsByName(that, name);
+  methods.forEach((method) => {
+    const event = __getEventNameByMethod(that, method, name);
+    elements.forEach((element) => element[action](event, that.__refsHandler));
+  });
+}
+function __manageChild(that, name, instance, mode = "add") {
+  const action = mode === "add" ? "$on" : "$off";
+  const methods = __getEventMethodsByName(that, name);
+  methods.forEach((method) => {
+    const event = __getEventNameByMethod(that, method, name);
+    instance[action](event, that.__childrenHandler);
+  });
+}
+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;
+    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 = EventsManager.normalizeName(event.type);
+        const normalizedEventName = normalizeName(event.type);
         const method = `on${normalizedEventName}`;
         this.__base[method](event);
       }
@@ -21,9 +70,9 @@ class EventsManager {
     __publicField(this, "__refsHandler", {
       handleEvent: (event) => {
         const ref = event.currentTarget;
-        const refName = RefsManager.normalizeRefName(ref.dataset.ref);
-        const normalizedRefName = EventsManager.normalizeName(refName);
-        const normalizedEventName = EventsManager.normalizeName(event.type);
+        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])) {
@@ -46,114 +95,41 @@ class EventsManager {
           }
           return false;
         });
-        const normalizedRefName = EventsManager.normalizeName(childName);
-        const normalizedEventName = EventsManager.normalizeName(event.type);
+        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);
       }
     });
-    Object.defineProperties(this, {
-      __rootElement: {
-        enumerable: false,
-        writable: false,
-        value: rootElement
-      },
-      __base: {
-        enumerable: false,
-        writable: false,
-        value: base
-      },
-      __methodsCache: {
-        enumerable: false,
-        writable: false,
-        value: this.__methodsCache
-      },
-      __rootElementHandler: {
-        enumerable: false,
-        writable: false,
-        value: this.__rootElementHandler
-      },
-      __refsHandler: {
-        enumerable: false,
-        writable: false,
-        value: this.__refsHandler
-      },
-      __childrenHandler: {
-        enumerable: false,
-        writable: false,
-        value: this.__childrenHandler
-      }
-    });
-  }
-  __manageRef(name, elements, mode = "add") {
-    const action = `${mode}EventListener`;
-    const methods = this.__getEventMethodsByName(name);
-    methods.forEach((method) => {
-      const event = this.__getEventNameByMethod(method, name);
-      elements.forEach((element) => element[action](event, this.__refsHandler));
-    });
+    this.__hideProperties([
+      "__methodsCache",
+      "__rootElementHandler",
+      "__refsHandler",
+      "__childrenHandler"
+    ]);
   }
   bindRef(name, elements) {
-    this.__manageRef(name, elements);
+    __manageRef(this, name, elements);
   }
   unbindRef(name, elements) {
-    this.__manageRef(name, elements, "remove");
-  }
-  __manageChild(name, instance, mode = "add") {
-    const action = mode === "add" ? "$on" : "$off";
-    const methods = this.__getEventMethodsByName(name);
-    methods.forEach((method) => {
-      const event = this.__getEventNameByMethod(method, name);
-      instance[action](event, this.__childrenHandler);
-    });
+    __manageRef(this, name, elements, "remove");
   }
   bindChild(name, instance) {
-    this.__manageChild(name, instance);
+    __manageChild(this, name, instance);
   }
   unbindChild(name, instance) {
-    this.__manageChild(name, instance, "remove");
-  }
-  __manageRootElement(mode = "add") {
-    const modeMethod = `${mode}EventListener`;
-    const methods = this.__getEventMethodsByName();
-    const { emits = [] } = this.__base.__config;
-    methods.forEach((method) => {
-      const event = this.__getEventNameByMethod(method);
-      const target = emits.includes(event) ? this.__base : this.__rootElement;
-      target[modeMethod](event, this.__rootElementHandler);
-    });
+    __manageChild(this, name, instance, "remove");
   }
   bindRootElement() {
-    this.__manageRootElement();
+    __manageRootElement(this);
   }
   unbindRootElement() {
-    this.__manageRootElement("remove");
-  }
-  __getEventNameByMethod(method, name = "") {
-    const normalizedName = EventsManager.normalizeName(name);
-    const regex = new RegExp(`^on${normalizedName}([A-Z].*)$`);
-    const [, event] = method.match(regex);
-    return EventsManager.normalizeEventName(event);
-  }
-  __getEventMethodsByName(name = "") {
-    const normalizedName = EventsManager.normalizeName(name);
-    const regex = new RegExp(`^on${normalizedName}[A-Z].*$`);
-    const key = regex.toString();
-    let methods = this.__methodsCache.get(key);
-    if (!methods) {
-      methods = Array.from(getAllProperties(this.__base, [], (method) => regex.test(method)).reduce((set, [method]) => set.add(method), /* @__PURE__ */ new Set()));
-      this.__methodsCache.set(key, methods);
-    }
-    return methods;
-  }
-  static normalizeName(name) {
-    return 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();
-  }
-  static normalizeEventName(name) {
-    return name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, "");
+    __manageRootElement(this, "remove");
   }
 }
 export {
-  EventsManager as default
+  EventsManager as default,
+  normalizeEventName,
+  normalizeName
 };

package/Base/managers/OptionsManager.cjs

@@ -27,84 +27,84 @@ var __publicField = (obj, key, value) => {
 // packages/js-toolkit/Base/managers/OptionsManager.js
 var OptionsManager_exports = {};
 __export(OptionsManager_exports, {
+  __getPropertyName: () => __getPropertyName,
   default: () => OptionsManager
 });
 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 _OptionsManager = class {
-  constructor(element, schema, baseConfig) {
-    __publicField(this, "__element");
+var types = /* @__PURE__ */ new Set([String, Number, Boolean, Array, Object]);
+var __defaultValues = {
+  String: "",
+  Number: 0,
+  Boolean: false,
+  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;
+  if (__propertyNameCache.has(key)) {
+    return __propertyNameCache.get(key);
+  }
+  const propertyName = `option${prefix}${name.replace(/^\w/, (c) => c.toUpperCase())}`;
+  __propertyNameCache.set(key, propertyName);
+  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.`);
+  }
+  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.`);
+  }
+  Object.defineProperty(that, name, {
+    get: () => {
+      return that.get(name, config);
+    },
+    set: (value) => {
+      that.set(name, value, config);
+    },
+    enumerable: true
+  });
+}
+var OptionsManager = class extends import_AbstractManager.default {
+  constructor(base) {
+    super(base);
     __publicField(this, "__values", {});
-    __publicField(this, "__defaultValues", {
-      String: "",
-      Number: 0,
-      Boolean: false,
-      Array: () => [],
-      Object: () => ({})
-    });
     __publicField(this, "name", "Base");
     __publicField(this, "debug", false);
     __publicField(this, "log", false);
     var _a, _b;
-    Object.defineProperties(this, {
-      __element: {
-        enumerable: false,
-        writable: false,
-        value: element
-      },
-      __values: {
-        enumerable: false,
-        writable: false,
-        value: this.__values
-      },
-      __defaultValues: {
-        enumerable: false,
-        writable: false,
-        value: this.__defaultValues
-      }
-    });
-    this.name = baseConfig.name;
+    this.__hideProperties(["__values", "__defaultValues"]);
+    const schema = this.__config.options || {};
+    this.name = this.__config.name;
     schema.debug = {
       type: Boolean,
-      default: (_a = baseConfig.debug) != null ? _a : false
+      default: (_a = this.__config.debug) != null ? _a : false
     };
     schema.log = {
       type: Boolean,
-      default: (_b = baseConfig.log) != null ? _b : false
+      default: (_b = this.__config.log) != null ? _b : false
     };
     Object.entries(schema).forEach(([name, config]) => {
-      this.__register(name, config);
+      __register(this, name, types.has(config) ? { type: config } : config);
     });
   }
-  __register(name, config) {
-    const isObjectConfig = typeof config === "object";
-    const hasDefaultValue = !_OptionsManager.types.includes(config);
-    const type = isObjectConfig ? config.type : config;
-    if (!_OptionsManager.types.includes(type)) {
-      throw new Error(`The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`);
-    }
-    const defaultValue = hasDefaultValue ? config.default : this.__defaultValues[type.name];
-    if ((type === Array || type === Object) && typeof defaultValue !== "function") {
-      throw new Error(`The default value for options of type "${type.name}" must be returned by a function.`);
-    }
-    Object.defineProperty(this, name, {
-      get: () => {
-        return this.get(name, type, defaultValue, isObjectConfig ? config.merge : void 0);
-      },
-      set: (value) => {
-        this.set(name, type, value, defaultValue);
-      },
-      enumerable: true
-    });
-  }
-  get(name, type, defaultValue, merge) {
-    const propertyName = _OptionsManager.__getPropertyName(name);
-    const hasProperty = this.__hasProperty(propertyName);
+  get(name, config) {
+    const { type, default: defaultValue } = config;
+    const propertyName = __getPropertyName(name);
+    const hasProperty = __hasProperty(this, propertyName);
     if (type === Boolean) {
       if (defaultValue) {
-        const negatedPropertyName = _OptionsManager.__getPropertyName(name, "No");
-        const hasNegatedProperty = this.__hasProperty(negatedPropertyName);
+        const negatedPropertyName = __getPropertyName(name, "No");
+        const hasNegatedProperty = __hasProperty(this, negatedPropertyName);
         return !hasNegatedProperty;
       }
       return hasProperty || defaultValue;
@@ -114,10 +114,11 @@ var _OptionsManager = class {
       return hasProperty ? Number(value) : defaultValue;
     }
     if (type === Array || type === Object) {
+      config = type === Array ? config : config;
       if (!this.__values[name]) {
-        let val = hasProperty ? JSON.parse(value) : defaultValue();
-        if (typeof merge !== "undefined") {
-          val = typeof merge === "boolean" ? (0, import_deepmerge.default)(defaultValue(), val) : (0, import_deepmerge.default)(defaultValue(), val, merge);
+        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);
         }
         this.__values[name] = val;
       }
@@ -125,8 +126,9 @@ var _OptionsManager = class {
     }
     return hasProperty ? value : defaultValue;
   }
-  set(name, type, value, defaultValue) {
-    const propertyName = _OptionsManager.__getPropertyName(name);
+  set(name, value, config) {
+    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}"`);
@@ -134,7 +136,7 @@ var _OptionsManager = class {
     switch (type) {
       case Boolean:
         if (defaultValue) {
-          const negatedPropertyName = _OptionsManager.__getPropertyName(name, "No");
+          const negatedPropertyName = __getPropertyName(name, "No");
           if (value) {
             delete this.__element.dataset[negatedPropertyName];
           } else {
@@ -154,20 +156,5 @@ var _OptionsManager = class {
         this.__element.dataset[propertyName] = value;
     }
   }
-  __hasProperty(prop) {
-    return typeof this.__element.dataset[prop] !== "undefined";
-  }
-  static __getPropertyName(name, prefix = "") {
-    const key = name + prefix;
-    if (_OptionsManager.__propertyNameCache.has(key)) {
-      return _OptionsManager.__propertyNameCache.get(key);
-    }
-    const propertyName = `option${prefix}${name.replace(/^\w/, (c) => c.toUpperCase())}`;
-    _OptionsManager.__propertyNameCache.set(key, propertyName);
-    return propertyName;
-  }
 };
-var OptionsManager = _OptionsManager;
-__publicField(OptionsManager, "types", [String, Number, Boolean, Array, Object]);
-__publicField(OptionsManager, "__propertyNameCache", /* @__PURE__ */ new Map());
 if (module.exports.default) module.exports = module.exports.default;