@studiometa/js-toolkit 2.3.0 → 2.4.0

package/Base/index.cjs

@@ -73,11 +73,43 @@ function createAndTestManagers(instance) {
   });
 }
 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) {
+      if (import_utils2.isDev) {
+        throw new Error("The root element must be defined.");
+      }
+      return;
+    }
+    const { __config } = this;
+    if (__config.name === "Base") {
+      if (import_utils2.isDev) {
+        throw new Error("The `config.name` property is required.");
+      }
+      return;
+    }
+    this.$id = `${__config.name}-${id}`;
+    id += 1;
+    this.$el = element;
+    if (!this.$el.__base__) {
+      this.$el.__base__ = /* @__PURE__ */ new WeakMap();
+    }
+    this.$el.__base__.set(this.__ctor, this);
+    createAndTestManagers(this);
+    if (import_utils2.isDev) {
+      this.__debug("constructor", this);
+    }
+  }
   get $root() {
     if (!this.$parent) {
       return this;
@@ -93,6 +125,7 @@ var Base = class extends EventTarget {
     return root;
   }
   get __config() {
+    var _a, _b, _c;
     let proto = Object.getPrototypeOf(this);
     let { config } = proto.constructor;
     while (proto.constructor.config && proto.constructor.$isBase) {
@@ -105,28 +138,23 @@ var Base = class extends EventTarget {
       }
       proto = Object.getPrototypeOf(proto);
     }
-    config.options = config.options ?? {};
-    config.refs = config.refs ?? [];
-    config.components = config.components ?? {};
+    config.options = (_a = config.options) != null ? _a : {};
+    config.refs = (_b = config.refs) != null ? _b : [];
+    config.components = (_c = config.components) != null ? _c : {};
     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}]`) : import_utils2.noop;
   }
@@ -159,33 +187,6 @@ var Base = class extends EventTarget {
     const eventHandlers = this.__eventHandlers.get(event);
     return eventHandlers && eventHandlers.size > 0;
   }
-  constructor(element) {
-    super();
-    if (!element) {
-      if (import_utils2.isDev) {
-        throw new Error("The root element must be defined.");
-      }
-      return;
-    }
-    const { __config } = this;
-    if (__config.name === "Base") {
-      if (import_utils2.isDev) {
-        throw new Error("The `config.name` property is required.");
-      }
-      return;
-    }
-    this.$id = `${__config.name}-${id}`;
-    id += 1;
-    this.$el = element;
-    if (!this.$el.__base__) {
-      this.$el.__base__ = /* @__PURE__ */ new WeakMap();
-    }
-    this.$el.__base__.set(this.__ctor, this);
-    createAndTestManagers(this);
-    if (import_utils2.isDev) {
-      this.__debug("constructor", this);
-    }
-  }
   $mount() {
     if (this.$isMounted) {
       return this;

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, getEventTarget } from "./utils.js";
 import ChildrenManager from "./managers/ChildrenManager.js";
 import RefsManager from "./managers/RefsManager.js";
@@ -41,12 +47,43 @@ function createAndTestManagers(instance) {
   });
 }
 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) {
+      if (isDev) {
+        throw new Error("The root element must be defined.");
+      }
+      return;
+    }
+    const { __config } = this;
+    if (__config.name === "Base") {
+      if (isDev) {
+        throw new Error("The `config.name` property is required.");
+      }
+      return;
+    }
+    this.$id = `${__config.name}-${id}`;
+    id += 1;
+    this.$el = element;
+    if (!this.$el.__base__) {
+      this.$el.__base__ = /* @__PURE__ */ new WeakMap();
+    }
+    this.$el.__base__.set(this.__ctor, this);
+    createAndTestManagers(this);
+    if (isDev) {
+      this.__debug("constructor", this);
+    }
+  }
   get $root() {
     if (!this.$parent) {
       return this;
@@ -62,6 +99,7 @@ class Base extends EventTarget {
     return root;
   }
   get __config() {
+    var _a, _b, _c;
     let proto = Object.getPrototypeOf(this);
     let { config } = proto.constructor;
     while (proto.constructor.config && proto.constructor.$isBase) {
@@ -74,44 +112,23 @@ class Base extends EventTarget {
       }
       proto = Object.getPrototypeOf(proto);
     }
-    config.options = config.options ?? {};
-    config.refs = config.refs ?? [];
-    config.components = config.components ?? {};
+    config.options = (_a = config.options) != null ? _a : {};
+    config.refs = (_b = config.refs) != null ? _b : [];
+    config.components = (_c = config.components) != null ? _c : {};
     return config;
   }
-  static config = {
-    name: "Base",
-    emits: [
-      "before-mounted",
-      "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;
   }
@@ -144,33 +161,6 @@ class Base extends EventTarget {
     const eventHandlers = this.__eventHandlers.get(event);
     return eventHandlers && eventHandlers.size > 0;
   }
-  constructor(element) {
-    super();
-    if (!element) {
-      if (isDev) {
-        throw new Error("The root element must be defined.");
-      }
-      return;
-    }
-    const { __config } = this;
-    if (__config.name === "Base") {
-      if (isDev) {
-        throw new Error("The `config.name` property is required.");
-      }
-      return;
-    }
-    this.$id = `${__config.name}-${id}`;
-    id += 1;
-    this.$el = element;
-    if (!this.$el.__base__) {
-      this.$el.__base__ = /* @__PURE__ */ new WeakMap();
-    }
-    this.$el.__base__.set(this.__ctor, this);
-    createAndTestManagers(this);
-    if (isDev) {
-      this.__debug("constructor", this);
-    }
-  }
   $mount() {
     if (this.$isMounted) {
       return this;
@@ -277,6 +267,23 @@ class Base extends EventTarget {
     return getComponentElements(nameOrSelector).map((el) => new this(el).$mount());
   }
 }
+__publicField(Base, "$isBase", true);
+__publicField(Base, "config", {
+  name: "Base",
+  emits: [
+    "before-mounted",
+    "mounted",
+    "updated",
+    "destroyed",
+    "terminated",
+    "ticked",
+    "scrolled",
+    "resized",
+    "moved",
+    "loaded",
+    "keyed"
+  ]
+});
 export {
   Base as default
 };

package/Base/managers/AbstractManager.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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,6 +16,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // packages/js-toolkit/Base/managers/AbstractManager.js
 var AbstractManager_exports = {};
@@ -23,7 +28,11 @@ __export(AbstractManager_exports, {
 });
 module.exports = __toCommonJS(AbstractManager_exports);
 var AbstractManager = class {
-  __base;
+  constructor(base) {
+    __publicField(this, "__base");
+    this.__base = base;
+    this.__hideProperties(["__base"]);
+  }
   get __element() {
     return this.__base.$el;
   }
@@ -33,10 +42,6 @@ var AbstractManager = class {
   get __eventsManager() {
     return this.__base.__events;
   }
-  constructor(base) {
-    this.__base = base;
-    this.__hideProperties(["__base"]);
-  }
   __hideProperties(properties) {
     Object.defineProperties(this, Object.fromEntries(properties.map((property) => [
       property,

package/Base/managers/AbstractManager.js

@@ -1,5 +1,15 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class AbstractManager {
-  __base;
+  constructor(base) {
+    __publicField(this, "__base");
+    this.__base = base;
+    this.__hideProperties(["__base"]);
+  }
   get __element() {
     return this.__base.$el;
   }
@@ -9,10 +19,6 @@ class AbstractManager {
   get __eventsManager() {
     return this.__base.__events;
   }
-  constructor(base) {
-    this.__base = base;
-    this.__hideProperties(["__base"]);
-  }
   __hideProperties(properties) {
     Object.defineProperties(this, Object.fromEntries(properties.map((property) => [
       property,

package/Base/managers/ChildrenManager.cjs

@@ -4,6 +4,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -18,6 +19,10 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // packages/js-toolkit/Base/managers/ChildrenManager.js
 var ChildrenManager_exports = {};
@@ -50,7 +55,8 @@ function __getChild(that, el, ComponentClass, name) {
     });
   }
   return promise.then((module2) => {
-    const ctor = module2.default ?? module2;
+    var _a;
+    const ctor = (_a = module2.default) != null ? _a : module2;
     that.__asyncComponentPromises.set(ComponentClass, {
       promise,
       status: "resolved",
@@ -96,7 +102,10 @@ function __triggerHookForAll(that, hook) {
   });
 }
 var ChildrenManager = class extends import_AbstractManager.default {
-  __asyncComponentPromises = /* @__PURE__ */ new WeakMap();
+  constructor() {
+    super(...arguments);
+    __publicField(this, "__asyncComponentPromises", /* @__PURE__ */ new WeakMap());
+  }
   get registeredNames() {
     return Object.keys(this).filter((key) => !key.startsWith("__"));
   }

package/Base/managers/ChildrenManager.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 AbstractManager from "./AbstractManager.js";
 import { getComponentElements } from "../utils.js";
 function __getChild(that, el, ComponentClass, name) {
@@ -23,7 +29,8 @@ function __getChild(that, el, ComponentClass, name) {
     });
   }
   return promise.then((module) => {
-    const ctor = module.default ?? module;
+    var _a;
+    const ctor = (_a = module.default) != null ? _a : module;
     that.__asyncComponentPromises.set(ComponentClass, {
       promise,
       status: "resolved",
@@ -69,7 +76,10 @@ function __triggerHookForAll(that, hook) {
   });
 }
 class ChildrenManager extends AbstractManager {
-  __asyncComponentPromises = /* @__PURE__ */ new WeakMap();
+  constructor() {
+    super(...arguments);
+    __publicField(this, "__asyncComponentPromises", /* @__PURE__ */ new WeakMap());
+  }
   get registeredNames() {
     return Object.keys(this).filter((key) => !key.startsWith("__"));
   }

package/Base/managers/EventsManager.cjs

@@ -4,6 +4,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -18,6 +19,10 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // packages/js-toolkit/Base/managers/EventsManager.js
 var EventsManager_exports = {};
@@ -94,49 +99,49 @@ function manageRootElement(that, mode = "add") {
   });
 }
 var EventsManager = class extends import_AbstractManager.default {
-  __methodsCache = /* @__PURE__ */ new Map();
-  __rootElementHandler = {
-    handleEvent: (event) => {
-      const normalizedEventName = normalizeName(event.type);
-      const method = `on${normalizedEventName}`;
-      if (event instanceof CustomEvent && (0, import_utils.isArray)(event.detail) && event.detail.length) {
-        this.__base[method](...event.detail, event);
-      } else {
-        this.__base[method](event);
-      }
-    }
-  };
-  __refsHandler = {
-    handleEvent: (event) => {
-      const ref = event.currentTarget;
-      const refName = (0, import_RefsManager.normalizeRefName)(ref.dataset.ref);
-      const normalizedRefName = normalizeName(refName);
-      const normalizedEventName = normalizeName(event.type);
-      const method = `on${normalizedRefName}${normalizedEventName}`;
-      let index = 0;
-      if ((0, import_utils.isArray)(this.__base.$refs[refName])) {
-        index = this.__base.$refs[refName].indexOf(ref);
-      }
-      this.__base[method](event, index);
-    }
-  };
-  __childrenHandler = {
-    handleEvent: (event) => {
-      const childrenManager = this.__base.$children;
-      const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
-        name: childName,
-        child: childrenManager[childName].find((instance) => instance === event.currentTarget || instance.$el === event.currentTarget)
-      })).find(({ child }) => child);
-      const normalizedChildName = normalizeName(name);
-      const normalizedEventName = normalizeName(event.type);
-      const method = `on${normalizedChildName}${normalizedEventName}`;
-      const index = childrenManager[name].indexOf(resolvedChild);
-      const args = (0, import_utils.isArray)(event.detail) ? event.detail : [];
-      this.__base[method](...args, index, event);
-    }
-  };
   constructor(base) {
     super(base);
+    __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());
+    __publicField(this, "__rootElementHandler", {
+      handleEvent: (event) => {
+        const normalizedEventName = normalizeName(event.type);
+        const method = `on${normalizedEventName}`;
+        if (event instanceof CustomEvent && (0, import_utils.isArray)(event.detail) && event.detail.length) {
+          this.__base[method](...event.detail, event);
+        } else {
+          this.__base[method](event);
+        }
+      }
+    });
+    __publicField(this, "__refsHandler", {
+      handleEvent: (event) => {
+        const ref = event.currentTarget;
+        const refName = (0, import_RefsManager.normalizeRefName)(ref.dataset.ref);
+        const normalizedRefName = normalizeName(refName);
+        const normalizedEventName = normalizeName(event.type);
+        const method = `on${normalizedRefName}${normalizedEventName}`;
+        let index = 0;
+        if ((0, import_utils.isArray)(this.__base.$refs[refName])) {
+          index = this.__base.$refs[refName].indexOf(ref);
+        }
+        this.__base[method](event, index);
+      }
+    });
+    __publicField(this, "__childrenHandler", {
+      handleEvent: (event) => {
+        const childrenManager = this.__base.$children;
+        const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
+          name: childName,
+          child: childrenManager[childName].find((instance) => instance === event.currentTarget || instance.$el === event.currentTarget)
+        })).find(({ child }) => child);
+        const normalizedChildName = normalizeName(name);
+        const normalizedEventName = normalizeName(event.type);
+        const method = `on${normalizedChildName}${normalizedEventName}`;
+        const index = childrenManager[name].indexOf(resolvedChild);
+        const args = (0, import_utils.isArray)(event.detail) ? event.detail : [];
+        this.__base[method](...args, index, event);
+      }
+    });
     this.__hideProperties([
       "__methodsCache",
       "__rootElementHandler",

package/Base/managers/EventsManager.js

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 import getAllProperties from "../../utils/object/getAllProperties.js";
 import { isArray } from "../../utils/index.js";
 import { getEventTarget, eventIsNative, eventIsDefinedInConfig } from "../utils.js";
@@ -65,49 +71,49 @@ function manageRootElement(that, mode = "add") {
   });
 }
 class EventsManager extends AbstractManager {
-  __methodsCache = /* @__PURE__ */ new Map();
-  __rootElementHandler = {
-    handleEvent: (event) => {
-      const normalizedEventName = normalizeName(event.type);
-      const method = `on${normalizedEventName}`;
-      if (event instanceof CustomEvent && isArray(event.detail) && event.detail.length) {
-        this.__base[method](...event.detail, event);
-      } else {
-        this.__base[method](event);
-      }
-    }
-  };
-  __refsHandler = {
-    handleEvent: (event) => {
-      const ref = event.currentTarget;
-      const refName = normalizeRefName(ref.dataset.ref);
-      const normalizedRefName = normalizeName(refName);
-      const normalizedEventName = normalizeName(event.type);
-      const method = `on${normalizedRefName}${normalizedEventName}`;
-      let index = 0;
-      if (isArray(this.__base.$refs[refName])) {
-        index = this.__base.$refs[refName].indexOf(ref);
-      }
-      this.__base[method](event, index);
-    }
-  };
-  __childrenHandler = {
-    handleEvent: (event) => {
-      const childrenManager = this.__base.$children;
-      const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
-        name: childName,
-        child: childrenManager[childName].find((instance) => instance === event.currentTarget || instance.$el === event.currentTarget)
-      })).find(({ child }) => child);
-      const normalizedChildName = normalizeName(name);
-      const normalizedEventName = normalizeName(event.type);
-      const method = `on${normalizedChildName}${normalizedEventName}`;
-      const index = childrenManager[name].indexOf(resolvedChild);
-      const args = isArray(event.detail) ? event.detail : [];
-      this.__base[method](...args, index, event);
-    }
-  };
   constructor(base) {
     super(base);
+    __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());
+    __publicField(this, "__rootElementHandler", {
+      handleEvent: (event) => {
+        const normalizedEventName = normalizeName(event.type);
+        const method = `on${normalizedEventName}`;
+        if (event instanceof CustomEvent && isArray(event.detail) && event.detail.length) {
+          this.__base[method](...event.detail, event);
+        } else {
+          this.__base[method](event);
+        }
+      }
+    });
+    __publicField(this, "__refsHandler", {
+      handleEvent: (event) => {
+        const ref = event.currentTarget;
+        const refName = normalizeRefName(ref.dataset.ref);
+        const normalizedRefName = normalizeName(refName);
+        const normalizedEventName = normalizeName(event.type);
+        const method = `on${normalizedRefName}${normalizedEventName}`;
+        let index = 0;
+        if (isArray(this.__base.$refs[refName])) {
+          index = this.__base.$refs[refName].indexOf(ref);
+        }
+        this.__base[method](event, index);
+      }
+    });
+    __publicField(this, "__childrenHandler", {
+      handleEvent: (event) => {
+        const childrenManager = this.__base.$children;
+        const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
+          name: childName,
+          child: childrenManager[childName].find((instance) => instance === event.currentTarget || instance.$el === event.currentTarget)
+        })).find(({ child }) => child);
+        const normalizedChildName = normalizeName(name);
+        const normalizedEventName = normalizeName(event.type);
+        const method = `on${normalizedChildName}${normalizedEventName}`;
+        const index = childrenManager[name].indexOf(resolvedChild);
+        const args = isArray(event.detail) ? event.detail : [];
+        this.__base[method](...args, index, event);
+      }
+    });
     this.__hideProperties([
       "__methodsCache",
       "__rootElementHandler",