@studiometa/js-toolkit 2.0.0-rc.2 → 2.1.0

package/Base/managers/ChildrenManager.cjs

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
@@ -15,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -27,120 +30,96 @@ __export(ChildrenManager_exports, {
   default: () => ChildrenManager
 });
 module.exports = __toCommonJS(ChildrenManager_exports);
+var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
 var import_utils = require("../utils.cjs");
-var ChildrenManager = class {
-  constructor(base, element, components, eventsManager) {
-    __publicField(this, "__base");
-    __publicField(this, "__element");
-    __publicField(this, "__components");
-    __publicField(this, "__eventsManager");
-    __publicField(this, "__asyncComponentPromises", /* @__PURE__ */ new WeakMap());
-    Object.defineProperties(this, {
-      __base: {
-        enumerable: false,
-        writable: false,
-        value: base
-      },
-      __element: {
-        enumerable: false,
-        writable: false,
-        value: element
-      },
-      __components: {
-        enumerable: false,
-        writable: false,
-        value: components
-      },
-      __eventsManager: {
-        enumerable: false,
-        writable: false,
-        value: eventsManager
-      }
+function __getChild(that, el, ComponentClass, name) {
+  const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
+  if ("$isBase" in ComponentClass || asyncComponentPromise && asyncComponentPromise.status === "resolved") {
+    let ctor = ComponentClass;
+    if (asyncComponentPromise) {
+      ctor = asyncComponentPromise.ctor;
+    }
+    if (el.__base__ && el.__base__.has(ctor)) {
+      return el.__base__.get(ctor);
+    }
+    const child = new ctor(el);
+    Object.defineProperty(child, "$parent", { get: () => that.__base });
+    return child;
+  }
+  const promise = asyncComponentPromise ? asyncComponentPromise.promise : ComponentClass(that.__base);
+  if (!asyncComponentPromise) {
+    that.__asyncComponentPromises.set(ComponentClass, {
+      promise,
+      status: "pending",
+      ctor: void 0
     });
   }
-  get registeredNames() {
-    return Object.keys(this).filter((key) => !key.startsWith("__"));
+  return promise.then((module2) => {
+    var _a;
+    const ctor = (_a = module2.default) != null ? _a : module2;
+    that.__asyncComponentPromises.set(ComponentClass, {
+      promise,
+      status: "resolved",
+      ctor
+    });
+    return __getChild(that, el, ctor, name);
+  });
+}
+function __register(that, name, component) {
+  Object.defineProperty(that, name, {
+    enumerable: true,
+    configurable: true,
+    get: () => {
+      const elements = (0, import_utils.getComponentElements)(name, that.__element);
+      if (elements.length === 0) {
+        return [];
+      }
+      return elements.map((element) => __getChild(that, element, component, name)).filter((instance) => instance !== "terminated");
+    }
+  });
+}
+function __triggerHook(that, hook, instance, name) {
+  if (hook === "$update" && !instance.$isMounted) {
+    hook = "$mount";
   }
-  registerAll() {
-    Object.entries(this.__components).forEach(([name, component]) => this.__register(name, component));
+  if (hook === "$update" || hook === "$destroy") {
+    that.__eventsManager.unbindChild(name, instance);
   }
-  __register(name, component) {
-    Object.defineProperty(this, name, {
-      enumerable: true,
-      configurable: true,
-      get: () => {
-        const elements = (0, import_utils.getComponentElements)(name, this.__element);
-        if (elements.length === 0) {
-          return [];
-        }
-        return elements.map((element) => this.__getChild(element, component, name)).filter((instance) => instance !== "terminated");
-      }
-    });
+  if (hook === "$update" || hook === "$mount") {
+    that.__eventsManager.bindChild(name, instance);
   }
-  __getChild(el, ComponentClass, name) {
-    const asyncComponentPromise = this.__asyncComponentPromises.get(ComponentClass);
-    if ("$isBase" in ComponentClass || asyncComponentPromise && asyncComponentPromise.status === "resolved") {
-      let ctor = ComponentClass;
-      if (asyncComponentPromise) {
-        ctor = asyncComponentPromise.ctor;
-      }
-      if (el.__base__ && el.__base__.has(ctor)) {
-        return el.__base__.get(ctor);
+  instance[hook]();
+}
+function __triggerHookForAll(that, hook) {
+  that.registeredNames.forEach((name) => {
+    that[name].forEach((instance) => {
+      if (instance instanceof Promise) {
+        instance.then((resolvedInstance) => __triggerHook(that, hook, resolvedInstance, name));
+      } else {
+        __triggerHook(that, hook, instance, name);
       }
-      const child = new ctor(el);
-      Object.defineProperty(child, "$parent", { get: () => this.__base });
-      return child;
-    }
-    const promise = asyncComponentPromise ? asyncComponentPromise.promise : ComponentClass(this.__base);
-    if (!asyncComponentPromise) {
-      this.__asyncComponentPromises.set(ComponentClass, {
-        promise,
-        status: "pending",
-        ctor: void 0
-      });
-    }
-    return promise.then((module2) => {
-      var _a;
-      const ctor = (_a = module2.default) != null ? _a : module2;
-      this.__asyncComponentPromises.set(ComponentClass, {
-        promise,
-        status: "resolved",
-        ctor
-      });
-      return this.__getChild(el, ctor, name);
     });
+  });
+}
+var ChildrenManager = class extends import_AbstractManager.default {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "__asyncComponentPromises", /* @__PURE__ */ new WeakMap());
+  }
+  get registeredNames() {
+    return Object.keys(this).filter((key) => !key.startsWith("__"));
+  }
+  registerAll() {
+    Object.entries(this.__config.components).forEach(([name, component]) => __register(this, name, component));
   }
   mountAll() {
-    this.__triggerHookForAll("$mount");
+    __triggerHookForAll(this, "$mount");
   }
   updateAll() {
-    this.__triggerHookForAll("$update");
+    __triggerHookForAll(this, "$update");
   }
   destroyAll() {
-    this.__triggerHookForAll("$destroy");
-  }
-  __triggerHookForAll(hook) {
-    this.registeredNames.forEach((name) => {
-      this[name].forEach((instance) => {
-        if (instance instanceof Promise) {
-          instance.then((resolvedInstance) => this.__triggerHook(hook, resolvedInstance, name));
-        } else {
-          this.__triggerHook(hook, instance, name);
-        }
-      });
-    });
-  }
-  __triggerHook(hook, instance, name) {
-    if (hook === "$update" && !instance.$isMounted) {
-      hook = "$mount";
-    }
-    if (hook === "$update" || hook === "$destroy") {
-      this.__eventsManager.unbindChild(name, instance);
-    }
-    if (hook === "$update" || hook === "$mount") {
-      this.__eventsManager.bindChild(name, instance);
-    }
-    instance[hook]();
+    __triggerHookForAll(this, "$destroy");
   }
 };
 if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/ChildrenManager.d.ts

@@ -1,85 +1,26 @@
-/**
- * @typedef {import('../index.js').default} Base
- * @typedef {import('../index.js').BaseConstructor} BaseConstructor
- * @typedef {import('../index.js').BaseAsyncConstructor} BaseAsyncConstructor
- * @typedef {import('../index.js').BaseConfigComponents} BaseConfigComponents
- * @typedef {import('./EventsManager.js').default} EventsManager
- */
 /**
  * Children manager.
  */
-export default class ChildrenManager {
-    /**
-     * Class constructor.
-     * @param {Base} base
-     *   The component's instance.
-     * @param {HTMLElement} element
-     *   The component's root element
-     * @param {BaseConfigComponents} components
-     *   The children components' classes
-     * @param {EventsManager} eventsManager
-     */
-    constructor(base: Base, element: HTMLElement, components: BaseConfigComponents, eventsManager: EventsManager);
-    /**
-     * @type {Base}
-     * @private
-     */
-    private __base;
-    /**
-     * @type {HTMLElement}
-     * @private
-     */
-    private __element;
-    /**
-     * @type {BaseConfigComponents}
-     * @private
-     */
-    private __components;
-    /**
-     * @type {EventsManager}
-     * @private
-     */
-    private __eventsManager;
+export default class ChildrenManager extends AbstractManager {
     /**
      * Store async component promises to avoid calling them multiple times and
      * waiting for them when they are already resolved.
      *
-     * @private
      * @type {WeakMap<BaseAsyncConstructor, { promise: ReturnType<BaseAsyncConstructor>, status: 'pending'|'resolved', ctor?: BaseConstructor }>}
      */
-    private __asyncComponentPromises;
+    __asyncComponentPromises: WeakMap<BaseAsyncConstructor, {
+        promise: ReturnType<BaseAsyncConstructor>;
+        status: 'pending' | 'resolved';
+        ctor?: BaseConstructor;
+    }>;
     /**
-     * @return {string[]}
+     * @returns {string[]}
      */
     get registeredNames(): string[];
     /**
      * Register instances of all children components.
      */
     registerAll(): void;
-    /**
-     * Register instance of a child component.
-     *
-     * @param {string} name
-     *   The name of the child component.
-     * @param {BaseConstructor|BaseAsyncConstructor} component
-     *   A Base class or a Promise for async components.
-     * @private
-     */
-    private __register;
-    /**
-     * Get a child component's instance.
-     *
-     * @param {HTMLElement & { __base__?: WeakMap<BaseConstructor, Base> }} el
-     *   The root element of the child component.
-     * @param {BaseConstructor|BaseAsyncConstructor} ComponentClass
-     *   A Base class or a Promise for async components.
-     * @param {string} name
-     *   The name of the child component.
-     * @return {Base|Promise|'terminated'}
-     *   A Base instance or a Promise resolving to a Base instance.
-     * @private
-     */
-    private __getChild;
     /**
      * Mount all child component instances.
      */
@@ -92,25 +33,9 @@ export default class ChildrenManager {
      * Destroy all child component instances.
      */
     destroyAll(): void;
-    /**
-     * Execute the given hook for all children instances.
-     *
-     * @param {'$mount'|'$update'|'$destroy'} hook The hook to execute.
-     * @private
-     */
-    private __triggerHookForAll;
-    /**
-     * Execute the given hook for the given instance.
-     *
-     * @param {'$mount'|'$update'|'$destroy'} hook The hook to trigger.
-     * @param {Base} instance The target instance.
-     * @param {string} name The name of the component.
-     * @private
-     */
-    private __triggerHook;
 }
 export type Base = import('../index.js').default;
 export type BaseConstructor = import('../index.js').BaseConstructor;
 export type BaseAsyncConstructor = import('../index.js').BaseAsyncConstructor;
 export type BaseConfigComponents = import('../index.js').BaseConfigComponents;
-export type EventsManager = import('./EventsManager.js').default;
+import AbstractManager from "./AbstractManager.js";

package/Base/managers/ChildrenManager.js

@@ -4,120 +4,96 @@ 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";
-class ChildrenManager {
-  constructor(base, element, components, eventsManager) {
-    __publicField(this, "__base");
-    __publicField(this, "__element");
-    __publicField(this, "__components");
-    __publicField(this, "__eventsManager");
-    __publicField(this, "__asyncComponentPromises", /* @__PURE__ */ new WeakMap());
-    Object.defineProperties(this, {
-      __base: {
-        enumerable: false,
-        writable: false,
-        value: base
-      },
-      __element: {
-        enumerable: false,
-        writable: false,
-        value: element
-      },
-      __components: {
-        enumerable: false,
-        writable: false,
-        value: components
-      },
-      __eventsManager: {
-        enumerable: false,
-        writable: false,
-        value: eventsManager
-      }
+function __getChild(that, el, ComponentClass, name) {
+  const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
+  if ("$isBase" in ComponentClass || asyncComponentPromise && asyncComponentPromise.status === "resolved") {
+    let ctor = ComponentClass;
+    if (asyncComponentPromise) {
+      ctor = asyncComponentPromise.ctor;
+    }
+    if (el.__base__ && el.__base__.has(ctor)) {
+      return el.__base__.get(ctor);
+    }
+    const child = new ctor(el);
+    Object.defineProperty(child, "$parent", { get: () => that.__base });
+    return child;
+  }
+  const promise = asyncComponentPromise ? asyncComponentPromise.promise : ComponentClass(that.__base);
+  if (!asyncComponentPromise) {
+    that.__asyncComponentPromises.set(ComponentClass, {
+      promise,
+      status: "pending",
+      ctor: void 0
     });
   }
-  get registeredNames() {
-    return Object.keys(this).filter((key) => !key.startsWith("__"));
+  return promise.then((module) => {
+    var _a;
+    const ctor = (_a = module.default) != null ? _a : module;
+    that.__asyncComponentPromises.set(ComponentClass, {
+      promise,
+      status: "resolved",
+      ctor
+    });
+    return __getChild(that, el, ctor, name);
+  });
+}
+function __register(that, name, component) {
+  Object.defineProperty(that, name, {
+    enumerable: true,
+    configurable: true,
+    get: () => {
+      const elements = getComponentElements(name, that.__element);
+      if (elements.length === 0) {
+        return [];
+      }
+      return elements.map((element) => __getChild(that, element, component, name)).filter((instance) => instance !== "terminated");
+    }
+  });
+}
+function __triggerHook(that, hook, instance, name) {
+  if (hook === "$update" && !instance.$isMounted) {
+    hook = "$mount";
   }
-  registerAll() {
-    Object.entries(this.__components).forEach(([name, component]) => this.__register(name, component));
+  if (hook === "$update" || hook === "$destroy") {
+    that.__eventsManager.unbindChild(name, instance);
   }
-  __register(name, component) {
-    Object.defineProperty(this, name, {
-      enumerable: true,
-      configurable: true,
-      get: () => {
-        const elements = getComponentElements(name, this.__element);
-        if (elements.length === 0) {
-          return [];
-        }
-        return elements.map((element) => this.__getChild(element, component, name)).filter((instance) => instance !== "terminated");
-      }
-    });
+  if (hook === "$update" || hook === "$mount") {
+    that.__eventsManager.bindChild(name, instance);
   }
-  __getChild(el, ComponentClass, name) {
-    const asyncComponentPromise = this.__asyncComponentPromises.get(ComponentClass);
-    if ("$isBase" in ComponentClass || asyncComponentPromise && asyncComponentPromise.status === "resolved") {
-      let ctor = ComponentClass;
-      if (asyncComponentPromise) {
-        ctor = asyncComponentPromise.ctor;
-      }
-      if (el.__base__ && el.__base__.has(ctor)) {
-        return el.__base__.get(ctor);
+  instance[hook]();
+}
+function __triggerHookForAll(that, hook) {
+  that.registeredNames.forEach((name) => {
+    that[name].forEach((instance) => {
+      if (instance instanceof Promise) {
+        instance.then((resolvedInstance) => __triggerHook(that, hook, resolvedInstance, name));
+      } else {
+        __triggerHook(that, hook, instance, name);
       }
-      const child = new ctor(el);
-      Object.defineProperty(child, "$parent", { get: () => this.__base });
-      return child;
-    }
-    const promise = asyncComponentPromise ? asyncComponentPromise.promise : ComponentClass(this.__base);
-    if (!asyncComponentPromise) {
-      this.__asyncComponentPromises.set(ComponentClass, {
-        promise,
-        status: "pending",
-        ctor: void 0
-      });
-    }
-    return promise.then((module) => {
-      var _a;
-      const ctor = (_a = module.default) != null ? _a : module;
-      this.__asyncComponentPromises.set(ComponentClass, {
-        promise,
-        status: "resolved",
-        ctor
-      });
-      return this.__getChild(el, ctor, name);
     });
+  });
+}
+class ChildrenManager extends AbstractManager {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "__asyncComponentPromises", /* @__PURE__ */ new WeakMap());
+  }
+  get registeredNames() {
+    return Object.keys(this).filter((key) => !key.startsWith("__"));
+  }
+  registerAll() {
+    Object.entries(this.__config.components).forEach(([name, component]) => __register(this, name, component));
   }
   mountAll() {
-    this.__triggerHookForAll("$mount");
+    __triggerHookForAll(this, "$mount");
   }
   updateAll() {
-    this.__triggerHookForAll("$update");
+    __triggerHookForAll(this, "$update");
   }
   destroyAll() {
-    this.__triggerHookForAll("$destroy");
-  }
-  __triggerHookForAll(hook) {
-    this.registeredNames.forEach((name) => {
-      this[name].forEach((instance) => {
-        if (instance instanceof Promise) {
-          instance.then((resolvedInstance) => this.__triggerHook(hook, resolvedInstance, name));
-        } else {
-          this.__triggerHook(hook, instance, name);
-        }
-      });
-    });
-  }
-  __triggerHook(hook, instance, name) {
-    if (hook === "$update" && !instance.$isMounted) {
-      hook = "$mount";
-    }
-    if (hook === "$update" || hook === "$destroy") {
-      this.__eventsManager.unbindChild(name, instance);
-    }
-    if (hook === "$update" || hook === "$mount") {
-      this.__eventsManager.bindChild(name, instance);
-    }
-    instance[hook]();
+    __triggerHookForAll(this, "$destroy");
   }
 }
 export {