@studiometa/js-toolkit 2.0.0-beta.13 → 2.0.0-beta.17

package/Base/index.cjs

@@ -47,11 +47,44 @@ var isDev = typeof __DEV__ !== "undefined" && __DEV__;
 function noop() {
 }
 var Base = class extends EventTarget {
-  $parent = null;
-  $id;
-  $el;
-  $isMounted = false;
-  __eventHandlers = /* @__PURE__ */ new Map();
+  constructor(element) {
+    super();
+    __publicField(this, "$parent", null);
+    __publicField(this, "$id");
+    __publicField(this, "$el");
+    __publicField(this, "$isMounted", false);
+    __publicField(this, "__eventHandlers", /* @__PURE__ */ new Map());
+    __publicField(this, "__services");
+    __publicField(this, "__refs");
+    __publicField(this, "__options");
+    __publicField(this, "__children");
+    __publicField(this, "__events");
+    if (!element) {
+      throw new Error("The root element must be defined.");
+    }
+    const { __config } = this;
+    if (__config.name === "Base") {
+      throw new Error("The `config.name` property is required.");
+    }
+    this.$id = `${__config.name}-${id}`;
+    id += 1;
+    this.$el = element;
+    if (!("__base__" in this.$el)) {
+      Object.defineProperty(this.$el, "__base__", {
+        get: () => this,
+        configurable: true
+      });
+    }
+    this.__options = new import_OptionsManager.default(element, __config.options || {}, __config);
+    this.__services = new import_ServicesManager.default(this);
+    this.__events = new import_EventsManager.default(element, this);
+    this.__children = new import_ChildrenManager.default(this, element, __config.components || {}, this.__events);
+    this.__refs = new import_RefsManager.default(this, element, __config.refs || [], this.__events);
+    if (isDev) {
+      this.__debug("constructor", this);
+    }
+    return this;
+  }
   get $root() {
     if (!this.$parent) {
       return this;
@@ -87,23 +120,18 @@ var Base = class extends EventTarget {
     }
     return config;
   }
-  __services;
   get $services() {
     return this.__services;
   }
-  __refs;
   get $refs() {
     return this.__refs;
   }
-  __options;
   get $options() {
     return this.__options;
   }
-  __children;
   get $children() {
     return this.__children;
   }
-  __events;
   get $log() {
     return this.__options.log ? window.console.log.bind(window, `[${this.__config.name}]`) : noop;
   }
@@ -127,34 +155,6 @@ var Base = class extends EventTarget {
     const eventHandlers = this.__eventHandlers.get(event);
     return eventHandlers && eventHandlers.size > 0;
   }
-  constructor(element) {
-    super();
-    if (!element) {
-      throw new Error("The root element must be defined.");
-    }
-    const { __config } = this;
-    if (__config.name === "Base") {
-      throw new Error("The `config.name` property is required.");
-    }
-    this.$id = `${__config.name}-${id}`;
-    id += 1;
-    this.$el = element;
-    if (!("__base__" in this.$el)) {
-      Object.defineProperty(this.$el, "__base__", {
-        get: () => this,
-        configurable: true
-      });
-    }
-    this.__options = new import_OptionsManager.default(element, __config.options || {}, __config);
-    this.__services = new import_ServicesManager.default(this);
-    this.__events = new import_EventsManager.default(element, this);
-    this.__children = new import_ChildrenManager.default(this, element, __config.components || {}, this.__events);
-    this.__refs = new import_RefsManager.default(this, element, __config.refs || [], this.__events);
-    if (isDev) {
-      this.__debug("constructor", this);
-    }
-    return this;
-  }
   $mount() {
     if (this.$isMounted) {
       return this;
@@ -292,3 +292,4 @@ __publicField(Base, "config", {
   ]
 });
 module.exports = __toCommonJS(Base_exports);
+if (module.exports.default) module.exports = module.exports.default;

package/Base/index.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 { getComponentElements } from "./utils.js";
 import ChildrenManager from "./managers/ChildrenManager.js";
 import RefsManager from "./managers/RefsManager.js";
@@ -9,12 +15,44 @@ const isDev = typeof __DEV__ !== "undefined" && __DEV__;
 function noop() {
 }
 class Base extends EventTarget {
-  static $isBase = true;
-  $parent = null;
-  $id;
-  $el;
-  $isMounted = false;
-  __eventHandlers = /* @__PURE__ */ new Map();
+  constructor(element) {
+    super();
+    __publicField(this, "$parent", null);
+    __publicField(this, "$id");
+    __publicField(this, "$el");
+    __publicField(this, "$isMounted", false);
+    __publicField(this, "__eventHandlers", /* @__PURE__ */ new Map());
+    __publicField(this, "__services");
+    __publicField(this, "__refs");
+    __publicField(this, "__options");
+    __publicField(this, "__children");
+    __publicField(this, "__events");
+    if (!element) {
+      throw new Error("The root element must be defined.");
+    }
+    const { __config } = this;
+    if (__config.name === "Base") {
+      throw new Error("The `config.name` property is required.");
+    }
+    this.$id = `${__config.name}-${id}`;
+    id += 1;
+    this.$el = element;
+    if (!("__base__" in this.$el)) {
+      Object.defineProperty(this.$el, "__base__", {
+        get: () => this,
+        configurable: true
+      });
+    }
+    this.__options = new OptionsManager(element, __config.options || {}, __config);
+    this.__services = new ServicesManager(this);
+    this.__events = new EventsManager(element, this);
+    this.__children = new ChildrenManager(this, element, __config.components || {}, this.__events);
+    this.__refs = new RefsManager(this, element, __config.refs || [], this.__events);
+    if (isDev) {
+      this.__debug("constructor", this);
+    }
+    return this;
+  }
   get $root() {
     if (!this.$parent) {
       return this;
@@ -50,38 +88,18 @@ class Base extends EventTarget {
     }
     return config;
   }
-  static config = {
-    name: "Base",
-    emits: [
-      "mounted",
-      "updated",
-      "destroyed",
-      "terminated",
-      "ticked",
-      "scrolled",
-      "resized",
-      "moved",
-      "loaded",
-      "keyed"
-    ]
-  };
-  __services;
   get $services() {
     return this.__services;
   }
-  __refs;
   get $refs() {
     return this.__refs;
   }
-  __options;
   get $options() {
     return this.__options;
   }
-  __children;
   get $children() {
     return this.__children;
   }
-  __events;
   get $log() {
     return this.__options.log ? window.console.log.bind(window, `[${this.__config.name}]`) : noop;
   }
@@ -105,34 +123,6 @@ class Base extends EventTarget {
     const eventHandlers = this.__eventHandlers.get(event);
     return eventHandlers && eventHandlers.size > 0;
   }
-  constructor(element) {
-    super();
-    if (!element) {
-      throw new Error("The root element must be defined.");
-    }
-    const { __config } = this;
-    if (__config.name === "Base") {
-      throw new Error("The `config.name` property is required.");
-    }
-    this.$id = `${__config.name}-${id}`;
-    id += 1;
-    this.$el = element;
-    if (!("__base__" in this.$el)) {
-      Object.defineProperty(this.$el, "__base__", {
-        get: () => this,
-        configurable: true
-      });
-    }
-    this.__options = new OptionsManager(element, __config.options || {}, __config);
-    this.__services = new ServicesManager(this);
-    this.__events = new EventsManager(element, this);
-    this.__children = new ChildrenManager(this, element, __config.components || {}, this.__events);
-    this.__refs = new RefsManager(this, element, __config.refs || [], this.__events);
-    if (isDev) {
-      this.__debug("constructor", this);
-    }
-    return this;
-  }
   $mount() {
     if (this.$isMounted) {
       return this;
@@ -253,6 +243,22 @@ class Base extends EventTarget {
     return getComponentElements(nameOrSelector).map((el) => new this(el).$mount());
   }
 }
+__publicField(Base, "$isBase", true);
+__publicField(Base, "config", {
+  name: "Base",
+  emits: [
+    "mounted",
+    "updated",
+    "destroyed",
+    "terminated",
+    "ticked",
+    "scrolled",
+    "resized",
+    "moved",
+    "loaded",
+    "keyed"
+  ]
+});
 export {
   Base as default
 };

package/Base/managers/ChildrenManager.cjs

@@ -2,6 +2,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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)
@@ -20,6 +21,10 @@ var __toCommonJS = /* @__PURE__ */ ((cache) => {
     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/ChildrenManager.js
 var ChildrenManager_exports = {};
@@ -28,14 +33,11 @@ __export(ChildrenManager_exports, {
 });
 var import_utils = require("../utils.cjs");
 var ChildrenManager = class {
-  __base;
-  __element;
-  __components;
-  __eventsManager;
-  get registeredNames() {
-    return Object.keys(this).filter((key) => !key.startsWith("__"));
-  }
   constructor(base, element, components, eventsManager) {
+    __publicField(this, "__base");
+    __publicField(this, "__element");
+    __publicField(this, "__components");
+    __publicField(this, "__eventsManager");
     Object.defineProperties(this, {
       __base: {
         enumerable: false,
@@ -59,6 +61,9 @@ var ChildrenManager = class {
       }
     });
   }
+  get registeredNames() {
+    return Object.keys(this).filter((key) => !key.startsWith("__"));
+  }
   registerAll() {
     Object.entries(this.__components).forEach(([name, component]) => this.__register(name, component));
   }
@@ -85,7 +90,8 @@ var ChildrenManager = class {
       return child;
     }
     return ComponentClass(this.__base).then((module2) => {
-      return this.__getChild(el, module2.default ?? module2, name);
+      var _a;
+      return this.__getChild(el, (_a = module2.default) != null ? _a : module2, name);
     });
   }
   mountAll() {
@@ -122,3 +128,4 @@ var ChildrenManager = class {
   }
 };
 module.exports = __toCommonJS(ChildrenManager_exports);
+if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/ChildrenManager.js

@@ -1,13 +1,16 @@
+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 { getComponentElements } from "../utils.js";
 class ChildrenManager {
-  __base;
-  __element;
-  __components;
-  __eventsManager;
-  get registeredNames() {
-    return Object.keys(this).filter((key) => !key.startsWith("__"));
-  }
   constructor(base, element, components, eventsManager) {
+    __publicField(this, "__base");
+    __publicField(this, "__element");
+    __publicField(this, "__components");
+    __publicField(this, "__eventsManager");
     Object.defineProperties(this, {
       __base: {
         enumerable: false,
@@ -31,6 +34,9 @@ class ChildrenManager {
       }
     });
   }
+  get registeredNames() {
+    return Object.keys(this).filter((key) => !key.startsWith("__"));
+  }
   registerAll() {
     Object.entries(this.__components).forEach(([name, component]) => this.__register(name, component));
   }
@@ -57,7 +63,8 @@ class ChildrenManager {
       return child;
     }
     return ComponentClass(this.__base).then((module) => {
-      return this.__getChild(el, module.default ?? module, name);
+      var _a;
+      return this.__getChild(el, (_a = module.default) != null ? _a : module, name);
     });
   }
   mountAll() {

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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -25,6 +26,10 @@ var __toCommonJS = /* @__PURE__ */ ((cache) => {
     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/EventsManager.js
 var EventsManager_exports = {};
@@ -34,52 +39,52 @@ __export(EventsManager_exports, {
 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);
+  constructor(rootElement, base) {
+    __publicField(this, "__rootElement");
+    __publicField(this, "__base");
+    __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());
+    __publicField(this, "__rootElementHandler", {
+      handleEvent: (event) => {
+        const normalizedEventName = EventsManager.normalizeName(event.type);
+        const method = `on${normalizedEventName}`;
+        this.__base[method](event);
       }
-      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;
+    });
+    __publicField(this, "__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);
         }
-        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) {
+        this.__base[method](event, index);
+      }
+    });
+    __publicField(this, "__childrenHandler", {
+      handleEvent: (event) => {
+        const child = event.currentTarget;
+        let childName;
+        let index = 0;
+        const childrenManager = this.__base.$children;
+        childrenManager.registeredNames.find((name) => {
+          if (childrenManager[name].includes(child)) {
+            childName = name;
+            index = childrenManager[name].indexOf(child);
+            return true;
+          }
+          return false;
+        });
+        const normalizedRefName = 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);
+      }
+    });
     Object.defineProperties(this, {
       __rootElement: {
         enumerable: false,
@@ -182,3 +187,4 @@ var EventsManager = class {
   }
 };
 module.exports = __toCommonJS(EventsManager_exports);
+if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/EventsManager.js

@@ -1,52 +1,58 @@
+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 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);
+  constructor(rootElement, base) {
+    __publicField(this, "__rootElement");
+    __publicField(this, "__base");
+    __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());
+    __publicField(this, "__rootElementHandler", {
+      handleEvent: (event) => {
+        const normalizedEventName = EventsManager.normalizeName(event.type);
+        const method = `on${normalizedEventName}`;
+        this.__base[method](event);
       }
-      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;
+    });
+    __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 method = `on${normalizedRefName}${normalizedEventName}`;
+        let index = 0;
+        if (Array.isArray(this.__base.$refs[refName])) {
+          index = this.__base.$refs[refName].indexOf(ref);
         }
-        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) {
+        this.__base[method](event, index);
+      }
+    });
+    __publicField(this, "__childrenHandler", {
+      handleEvent: (event) => {
+        const child = event.currentTarget;
+        let childName;
+        let index = 0;
+        const childrenManager = this.__base.$children;
+        childrenManager.registeredNames.find((name) => {
+          if (childrenManager[name].includes(child)) {
+            childName = name;
+            index = childrenManager[name].indexOf(child);
+            return true;
+          }
+          return false;
+        });
+        const normalizedRefName = 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);
+      }
+    });
     Object.defineProperties(this, {
       __rootElement: {
         enumerable: false,

package/Base/managers/OptionsManager.cjs

@@ -39,19 +39,20 @@ __export(OptionsManager_exports, {
 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) {
+    __publicField(this, "__element");
+    __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,
@@ -72,11 +73,11 @@ var _OptionsManager = class {
     this.name = baseConfig.name;
     schema.debug = {
       type: Boolean,
-      default: baseConfig.debug ?? false
+      default: (_a = baseConfig.debug) != null ? _a : false
     };
     schema.log = {
       type: Boolean,
-      default: baseConfig.log ?? false
+      default: (_b = baseConfig.log) != null ? _b : false
     };
     Object.entries(schema).forEach(([name, config]) => {
       this.__register(name, config);
@@ -173,3 +174,4 @@ 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;