@studiometa/js-toolkit 2.0.0-beta.10 → 2.0.0-beta.14

package/Base/managers/EventsManager.cjs

@@ -0,0 +1,185 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// packages/js-toolkit/Base/managers/EventsManager.js
+var EventsManager_exports = {};
+__export(EventsManager_exports, {
+  default: () => EventsManager
+});
+var import_getAllProperties = __toESM(require("../../utils/object/getAllProperties.cjs"), 1);
+var import_RefsManager = __toESM(require("./RefsManager.cjs"), 1);
+var EventsManager = class {
+  __rootElement;
+  __base;
+  __methodsCache = /* @__PURE__ */ new Map();
+  __rootElementHandler = {
+    handleEvent: (event) => {
+      const normalizedEventName = EventsManager.normalizeName(event.type);
+      const method = `on${normalizedEventName}`;
+      this.__base[method](event);
+    }
+  };
+  __refsHandler = {
+    handleEvent: (event) => {
+      const ref = event.currentTarget;
+      const refName = import_RefsManager.default.normalizeRefName(ref.dataset.ref);
+      const normalizedRefName = EventsManager.normalizeName(refName);
+      const normalizedEventName = EventsManager.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);
+    }
+  };
+  __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 = EventsManager.normalizeName(childName);
+      const normalizedEventName = EventsManager.normalizeName(event.type);
+      const method = `on${normalizedRefName}${normalizedEventName}`;
+      const args = Array.isArray(event.detail) ? event.detail : [];
+      this.__base[method](...args, index, event);
+    }
+  };
+  constructor(rootElement, base) {
+    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));
+    });
+  }
+  bindRef(name, elements) {
+    this.__manageRef(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);
+    });
+  }
+  bindChild(name, instance) {
+    this.__manageChild(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);
+    });
+  }
+  bindRootElement() {
+    this.__manageRootElement();
+  }
+  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((0, import_getAllProperties.default)(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(/^-/, "");
+  }
+};
+module.exports = __toCommonJS(EventsManager_exports);
+if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/EventsManager.js

@@ -1,64 +1,52 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import getAllProperties from '../../utils/object/getAllProperties.js';
-import RefsManager from './RefsManager.js';
-export default class EventsManager {
-  constructor(rootElement, base) {
-    _defineProperty(this, "__rootElement", void 0);
-
-    _defineProperty(this, "__base", void 0);
-
-    _defineProperty(this, "__methodsCache", new Map());
-
-    _defineProperty(this, "__rootElementHandler", {
-      handleEvent: event => {
-        var normalizedEventName = EventsManager.normalizeName(event.type);
-        var method = "on".concat(normalizedEventName);
-
-        this.__base[method](event);
+import getAllProperties from "../../utils/object/getAllProperties.js";
+import RefsManager from "./RefsManager.js";
+class EventsManager {
+  __rootElement;
+  __base;
+  __methodsCache = /* @__PURE__ */ new Map();
+  __rootElementHandler = {
+    handleEvent: (event) => {
+      const normalizedEventName = EventsManager.normalizeName(event.type);
+      const method = `on${normalizedEventName}`;
+      this.__base[method](event);
+    }
+  };
+  __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 method = `on${normalizedRefName}${normalizedEventName}`;
+      let index = 0;
+      if (Array.isArray(this.__base.$refs[refName])) {
+        index = this.__base.$refs[refName].indexOf(ref);
       }
-    });
-
-    _defineProperty(this, "__refsHandler", {
-      handleEvent: event => {
-        var ref = event.currentTarget;
-        var refName = RefsManager.normalizeRefName(ref.dataset.ref);
-        var normalizedRefName = EventsManager.normalizeName(refName);
-        var normalizedEventName = EventsManager.normalizeName(event.type);
-        var method = "on".concat(normalizedRefName).concat(normalizedEventName);
-        var index = 0;
-
-        if (Array.isArray(this.__base.$refs[refName])) {
-          index = this.__base.$refs[refName].indexOf(ref);
+      this.__base[method](event, index);
+    }
+  };
+  __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;
         }
-
-        this.__base[method](event, index);
-      }
-    });
-
-    _defineProperty(this, "__childrenHandler", {
-      handleEvent: event => {
-        var child = event.currentTarget;
-        var childName;
-        var index = 0;
-        var childrenManager = this.__base.$children;
-        childrenManager.registeredNames.find(name => {
-          if (childrenManager[name].includes(child)) {
-            childName = name;
-            index = childrenManager[name].indexOf(child);
-            return true;
-          }
-
-          return false;
-        });
-        var normalizedRefName = EventsManager.normalizeName(childName);
-        var normalizedEventName = EventsManager.normalizeName(event.type);
-        var method = "on".concat(normalizedRefName).concat(normalizedEventName);
-        var args = Array.isArray(event.detail) ? event.detail : [];
-
-        this.__base[method](...args, index, event);
-      }
-    });
-
+        return false;
+      });
+      const normalizedRefName = EventsManager.normalizeName(childName);
+      const normalizedEventName = EventsManager.normalizeName(event.type);
+      const method = `on${normalizedRefName}${normalizedEventName}`;
+      const args = Array.isArray(event.detail) ? event.detail : [];
+      this.__base[method](...args, index, event);
+    }
+  };
+  constructor(rootElement, base) {
     Object.defineProperties(this, {
       __rootElement: {
         enumerable: false,
@@ -92,108 +80,74 @@ export default class EventsManager {
       }
     });
   }
-
-  __manageRef(name, elements) {
-    var mode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'add';
-    var action = "".concat(mode, "EventListener");
-
-    var methods = this.__getEventMethodsByName(name);
-
-    methods.forEach(method => {
-      var event = this.__getEventNameByMethod(method, name);
-
-      elements.forEach(element => element[action](event, this.__refsHandler));
+  __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));
     });
   }
-
   bindRef(name, elements) {
     this.__manageRef(name, elements);
   }
-
   unbindRef(name, elements) {
-    this.__manageRef(name, elements, 'remove');
+    this.__manageRef(name, elements, "remove");
   }
-
-  __manageChild(name, instance) {
-    var mode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'add';
-    var action = mode === 'add' ? '$on' : '$off';
-
-    var methods = this.__getEventMethodsByName(name);
-
-    methods.forEach(method => {
-      var event = this.__getEventNameByMethod(method, name);
-
+  __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);
     });
   }
-
   bindChild(name, instance) {
     this.__manageChild(name, instance);
   }
-
   unbindChild(name, instance) {
-    this.__manageChild(name, instance, 'remove');
+    this.__manageChild(name, instance, "remove");
   }
-
-  __manageRootElement() {
-    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'add';
-    var modeMethod = "".concat(mode, "EventListener");
-
-    var methods = this.__getEventMethodsByName();
-
-    var {
-      emits = []
-    } = this.__base.__config;
-    methods.forEach(method => {
-      var event = this.__getEventNameByMethod(method);
-
-      var target = emits.includes(event) ? this.__base : this.__rootElement;
+  __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);
     });
   }
-
   bindRootElement() {
     this.__manageRootElement();
   }
-
   unbindRootElement() {
-    this.__manageRootElement('remove');
+    this.__manageRootElement("remove");
   }
-
-  __getEventNameByMethod(method) {
-    var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-    var normalizedName = EventsManager.normalizeName(name);
-    var regex = new RegExp("^on".concat(normalizedName, "([A-Z].*)$"));
-    var [, event] = method.match(regex);
+  __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() {
-    var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-    var normalizedName = EventsManager.normalizeName(name);
-    var regex = new RegExp("^on".concat(normalizedName, "[A-Z].*$"));
-    var key = regex.toString();
-
-    var methods = this.__methodsCache.get(key);
-
+  __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, _ref) => {
-        var [method] = _ref;
-        return set.add(method);
-      }, new Set()));
-
+      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();
+    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 => "-".concat(c.toLowerCase())).replace(/^-/, '');
+    return name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, "");
   }
-
-}
+}
+export {
+  EventsManager as default
+};

package/Base/managers/OptionsManager.cjs

@@ -0,0 +1,176 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+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 = {};
+__export(OptionsManager_exports, {
+  default: () => OptionsManager
+});
+var import_deepmerge = __toESM(require("deepmerge"), 1);
+var import_isObject = __toESM(require("../../utils/object/isObject.cjs"), 1);
+var _OptionsManager = class {
+  __element;
+  __values = {};
+  __defaultValues = {
+    String: "",
+    Number: 0,
+    Boolean: false,
+    Array: () => [],
+    Object: () => ({})
+  };
+  name = "Base";
+  debug = false;
+  log = false;
+  constructor(element, schema, baseConfig) {
+    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;
+    schema.debug = {
+      type: Boolean,
+      default: baseConfig.debug ?? false
+    };
+    schema.log = {
+      type: Boolean,
+      default: baseConfig.log ?? false
+    };
+    Object.entries(schema).forEach(([name, config]) => {
+      this.__register(name, config);
+    });
+    return this;
+  }
+  __register(name, config) {
+    const hasDefaultValue = !_OptionsManager.types.includes(config);
+    const type = hasDefaultValue ? 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);
+      },
+      set: (value) => {
+        this.set(name, type, value, defaultValue);
+      },
+      enumerable: true
+    });
+  }
+  get(name, type, defaultValue) {
+    const propertyName = _OptionsManager.__getPropertyName(name);
+    const hasProperty = this.__hasProperty(propertyName);
+    if (type === Boolean) {
+      if (defaultValue) {
+        const negatedPropertyName = _OptionsManager.__getPropertyName(name, "No");
+        const hasNegatedProperty = this.__hasProperty(negatedPropertyName);
+        return !hasNegatedProperty;
+      }
+      return hasProperty || defaultValue;
+    }
+    const value = this.__element.dataset[propertyName];
+    if (type === Number) {
+      return hasProperty ? Number(value) : defaultValue;
+    }
+    if (type === Array || type === Object) {
+      const val = (0, import_deepmerge.default)(defaultValue(), hasProperty ? JSON.parse(value) : this.__defaultValues[type.name]());
+      if (!this.__values[name]) {
+        this.__values[name] = val;
+      }
+      return this.__values[name];
+    }
+    return hasProperty ? value : defaultValue;
+  }
+  set(name, type, value, defaultValue) {
+    const propertyName = _OptionsManager.__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}"`);
+    }
+    switch (type) {
+      case Boolean:
+        if (defaultValue) {
+          const negatedPropertyName = _OptionsManager.__getPropertyName(name, "No");
+          if (value) {
+            delete this.__element.dataset[negatedPropertyName];
+          } else {
+            this.__element.dataset[negatedPropertyName] = "";
+          }
+        } else if (value) {
+          this.__element.dataset[propertyName] = "";
+        } else {
+          delete this.__element.dataset[propertyName];
+        }
+        break;
+      case Array:
+      case Object:
+        this.__values[name] = value;
+        break;
+      default:
+        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());
+module.exports = __toCommonJS(OptionsManager_exports);
+if (module.exports.default) module.exports = module.exports.default;