@studiometa/js-toolkit 3.9.0-beta.0 → 3.9.0-beta.2

package/dist/Base/managers/ChildrenManager.d.ts

@@ -0,0 +1,81 @@
+import type { Base, BaseAsyncConstructor, BaseConstructor, BaseEl } from '../Base.js';
+import { AbstractManager } from './AbstractManager.js';
+/**
+ * Children manager.
+ */
+export declare class ChildrenManager<T> extends AbstractManager<T> {
+    /**
+     * Store async component promises to avoid calling them multiple times and
+     * waiting for them when they are already resolved.
+     *
+     * Also read by `Base.__parent` (backing `$parent`/`$root`) to resolve an
+     * async/lazy-declared child to its parent: `config.components` holds the
+     * loader function, so `__parent` looks up its resolved `ctor` here to match by
+     * identity. Keep the `{ status, ctor }` shape in sync with that reader.
+     */
+    __asyncComponentPromises: WeakMap<BaseAsyncConstructor, {
+        promise: ReturnType<BaseAsyncConstructor>;
+        status: 'pending' | 'resolved';
+        ctor?: BaseConstructor;
+    }>;
+    get registeredNames(): string[];
+    /**
+     * Register instances of all children components.
+     */
+    registerAll(): Promise<void>;
+    /**
+     * Mount all child component instances.
+     */
+    mountAll(): Promise<void>;
+    /**
+     * Update all child component instances.
+     */
+    updateAll(): Promise<void>;
+    /**
+     * Destroy all child component instances.
+     */
+    destroyAll(): Promise<void>;
+    /**
+     * 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
+     */
+    __triggerHook(hook: '$mount' | '$update' | '$destroy', instance: Base, name: string): Promise<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
+     */
+    __register(name: string, component: BaseConstructor | BaseAsyncConstructor): void;
+    /**
+     * Get children.
+     * @private
+     */
+    __getValue(name: string, component: BaseConstructor | BaseAsyncConstructor): any[];
+    /**
+     * Get a child component's instance.
+     *
+     * @param {BaseEl} el
+     *   The root element of the child component.
+     * @param {BaseConstructor|BaseAsyncConstructor} ComponentClass
+     *   A Base class or a Promise for async components.
+     * @return {Base|Promise<Base | 'terminated'>|'terminated'}
+     *   A Base instance or a Promise resolving to a Base instance.
+     * @private
+     */
+    __getChild(el: BaseEl, ComponentClass: BaseConstructor | BaseAsyncConstructor): Base | Promise<Base | 'terminated'> | 'terminated';
+    /**
+     * Execute the given hook for all children instances.
+     *
+     * @param {'$mount'|'$update'|'$destroy'} hook The hook to execute.
+     * @private
+     */
+    __triggerHookForAll(hook: '$mount' | '$update' | '$destroy'): Promise<unknown>;
+}

package/dist/Base/managers/ChildrenManager.js

@@ -0,0 +1,168 @@
+import { addToQueue, getComponentElements } from "../utils.js";
+import { AbstractManager } from "./AbstractManager.js";
+class ChildrenManager extends AbstractManager {
+  /**
+   * Store async component promises to avoid calling them multiple times and
+   * waiting for them when they are already resolved.
+   *
+   * Also read by `Base.__parent` (backing `$parent`/`$root`) to resolve an
+   * async/lazy-declared child to its parent: `config.components` holds the
+   * loader function, so `__parent` looks up its resolved `ctor` here to match by
+   * identity. Keep the `{ status, ctor }` shape in sync with that reader.
+   */
+  __asyncComponentPromises = /* @__PURE__ */ new WeakMap();
+  get registeredNames() {
+    return Object.keys(this.props);
+  }
+  /**
+   * Register instances of all children components.
+   */
+  async registerAll() {
+    for (const [name, component] of Object.entries(this.__config.components)) {
+      this.__register(name, component);
+    }
+  }
+  /**
+   * Mount all child component instances.
+   */
+  async mountAll() {
+    await this.__triggerHookForAll("$mount");
+  }
+  /**
+   * Update all child component instances.
+   */
+  async updateAll() {
+    await this.__triggerHookForAll("$update");
+  }
+  /**
+   * Destroy all child component instances.
+   */
+  async destroyAll() {
+    await this.__triggerHookForAll("$destroy");
+  }
+  /**
+   * 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
+   */
+  async __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);
+    }
+    await instance[hook]();
+  }
+  /**
+   * 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
+   */
+  __register(name, component) {
+    Object.defineProperty(this.props, name, {
+      enumerable: true,
+      configurable: true,
+      get: () => this.__getValue(name, component)
+    });
+  }
+  /**
+   * Get children.
+   * @private
+   */
+  __getValue(name, component) {
+    const elements = getComponentElements(name, this.__element);
+    if (elements.length === 0) {
+      return [];
+    }
+    const children = [];
+    for (const element of elements) {
+      const child = this.__getChild(element, component);
+      if (child !== "terminated") {
+        children.push(child);
+      }
+    }
+    return children;
+  }
+  /**
+   * Get a child component's instance.
+   *
+   * @param {BaseEl} el
+   *   The root element of the child component.
+   * @param {BaseConstructor|BaseAsyncConstructor} ComponentClass
+   *   A Base class or a Promise for async components.
+   * @return {Base|Promise<Base | 'terminated'>|'terminated'}
+   *   A Base instance or a Promise resolving to a Base instance.
+   * @private
+   */
+  __getChild(el, ComponentClass) {
+    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.config.name)) {
+        return el.__base__.get(ctor.config.name);
+      }
+      const child = new ctor(el);
+      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) => {
+      const ctor = module.default ?? module;
+      this.__asyncComponentPromises.set(ComponentClass, {
+        promise,
+        status: "resolved",
+        ctor
+      });
+      return this.__getChild(el, ctor);
+    });
+  }
+  /**
+   * Execute the given hook for all children instances.
+   *
+   * @param {'$mount'|'$update'|'$destroy'} hook The hook to execute.
+   * @private
+   */
+  async __triggerHookForAll(hook) {
+    return addToQueue(() => {
+      const promises = [];
+      for (const name of this.registeredNames) {
+        for (const instance of this.props[name]) {
+          if (instance instanceof Promise) {
+            instance.then(
+              (resolvedInstance) => addToQueue(() => this.__triggerHook(hook, resolvedInstance, name))
+            );
+          } else {
+            promises.push(addToQueue(() => this.__triggerHook(hook, instance, name)));
+          }
+        }
+      }
+      return Promise.all(promises);
+    });
+  }
+}
+export {
+  ChildrenManager
+};
+//# sourceMappingURL=ChildrenManager.js.map

package/dist/Base/managers/ChildrenManager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../packages/js-toolkit/Base/managers/ChildrenManager.ts"],
+  "sourcesContent": ["import type { Base, BaseAsyncConstructor, BaseConstructor, BaseEl } from '../Base.js';\nimport { addToQueue, getComponentElements } from '../utils.js';\nimport { AbstractManager } from './AbstractManager.js';\n\n/**\n * Children manager.\n */\nexport class ChildrenManager<T> extends AbstractManager<T> {\n  /**\n   * Store async component promises to avoid calling them multiple times and\n   * waiting for them when they are already resolved.\n   *\n   * Also read by `Base.__parent` (backing `$parent`/`$root`) to resolve an\n   * async/lazy-declared child to its parent: `config.components` holds the\n   * loader function, so `__parent` looks up its resolved `ctor` here to match by\n   * identity. Keep the `{ status, ctor }` shape in sync with that reader.\n   */\n  __asyncComponentPromises: WeakMap<\n    BaseAsyncConstructor,\n    {\n      promise: ReturnType<BaseAsyncConstructor>;\n      status: 'pending' | 'resolved';\n      ctor?: BaseConstructor;\n    }\n  > = new WeakMap();\n\n  get registeredNames(): string[] {\n    return Object.keys(this.props);\n  }\n\n  /**\n   * Register instances of all children components.\n   */\n  async registerAll() {\n    for (const [name, component] of Object.entries(this.__config.components)) {\n      this.__register(name, component);\n    }\n  }\n\n  /**\n   * Mount all child component instances.\n   */\n  async mountAll() {\n    await this.__triggerHookForAll('$mount');\n  }\n\n  /**\n   * Update all child component instances.\n   */\n  async updateAll() {\n    await this.__triggerHookForAll('$update');\n  }\n\n  /**\n   * Destroy all child component instances.\n   */\n  async destroyAll() {\n    await this.__triggerHookForAll('$destroy');\n  }\n\n  /**\n   * Execute the given hook for the given instance.\n   *\n   * @param {'$mount'|'$update'|'$destroy'} hook The hook to trigger.\n   * @param {Base} instance The target instance.\n   * @param {string} name The name of the component.\n   * @private\n   */\n  async __triggerHook(hook: '$mount' | '$update' | '$destroy', instance: Base, name: string) {\n    if (hook === '$update' && !instance.$isMounted) {\n      // eslint-disable-next-line no-param-reassign\n      hook = '$mount';\n    }\n\n    if (hook === '$update' || hook === '$destroy') {\n      this.__eventsManager.unbindChild(name, instance);\n    }\n\n    if (hook === '$update' || hook === '$mount') {\n      this.__eventsManager.bindChild(name, instance);\n    }\n\n    await instance[hook]();\n  }\n\n  /**\n   * Register instance of a child component.\n   *\n   * @param {string} name\n   *   The name of the child component.\n   * @param {BaseConstructor|BaseAsyncConstructor} component\n   *   A Base class or a Promise for async components.\n   * @private\n   */\n  __register(name: string, component: BaseConstructor | BaseAsyncConstructor) {\n    Object.defineProperty(this.props, name, {\n      enumerable: true,\n      configurable: true,\n      get: () => this.__getValue(name, component),\n    });\n  }\n\n  /**\n   * Get children.\n   * @private\n   */\n  __getValue(name: string, component: BaseConstructor | BaseAsyncConstructor) {\n    const elements = getComponentElements(name, this.__element);\n\n    if (elements.length === 0) {\n      return [];\n    }\n\n    const children = [];\n    for (const element of elements) {\n      const child = this.__getChild(element, component);\n      if (child !== 'terminated') {\n        children.push(child);\n      }\n    }\n\n    return children;\n  }\n\n  /**\n   * Get a child component's instance.\n   *\n   * @param {BaseEl} el\n   *   The root element of the child component.\n   * @param {BaseConstructor|BaseAsyncConstructor} ComponentClass\n   *   A Base class or a Promise for async components.\n   * @return {Base|Promise<Base | 'terminated'>|'terminated'}\n   *   A Base instance or a Promise resolving to a Base instance.\n   * @private\n   */\n  __getChild(\n    el: BaseEl,\n    ComponentClass: BaseConstructor | BaseAsyncConstructor,\n  ): Base | Promise<Base | 'terminated'> | 'terminated' {\n    const asyncComponentPromise = this.__asyncComponentPromises.get(\n      ComponentClass as BaseAsyncConstructor,\n    );\n\n    // Test if we have a constructor and not a promise or if the promise has been resolved\n    if (\n      '$isBase' in ComponentClass ||\n      (asyncComponentPromise && asyncComponentPromise.status === 'resolved')\n    ) {\n      let ctor = ComponentClass as BaseConstructor;\n\n      // Get resolved constructor from weakmap.\n      // Only test for existence as the status was checked before.\n      if (asyncComponentPromise) {\n        ctor = asyncComponentPromise.ctor;\n      }\n\n      // Return existing instance if it exists\n      if (el.__base__ && el.__base__.has(ctor.config.name)) {\n        return el.__base__.get(ctor.config.name);\n      }\n\n      // Return a new instance if the component class is a child of the Base class\n      // eslint-disable-next-line new-cap\n      const child = new ctor(el);\n      return child;\n    }\n\n    const promise = asyncComponentPromise\n      ? asyncComponentPromise.promise\n      : ComponentClass(this.__base);\n\n    if (!asyncComponentPromise) {\n      this.__asyncComponentPromises.set(ComponentClass, {\n        promise,\n        status: 'pending',\n        ctor: undefined,\n      });\n    }\n\n    // Resolve async components\n    return promise.then((module) => {\n      // @ts-ignore\n      const ctor = module.default ?? module;\n\n      this.__asyncComponentPromises.set(ComponentClass, {\n        promise,\n        status: 'resolved',\n        ctor,\n      });\n\n      return this.__getChild(el, ctor);\n    });\n  }\n\n  /**\n   * Execute the given hook for all children instances.\n   *\n   * @param {'$mount'|'$update'|'$destroy'} hook The hook to execute.\n   * @private\n   */\n  async __triggerHookForAll(hook: '$mount' | '$update' | '$destroy') {\n    return addToQueue(() => {\n      const promises = [];\n      for (const name of this.registeredNames) {\n        for (const instance of this.props[name]) {\n          if (instance instanceof Promise) {\n            instance.then((resolvedInstance) =>\n              addToQueue(() => this.__triggerHook(hook, resolvedInstance, name)),\n            );\n          } else {\n            promises.push(addToQueue(() => this.__triggerHook(hook, instance, name)));\n          }\n        }\n      }\n      return Promise.all(promises);\n    });\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/Base/managers/EventsManager.d.ts

@@ -0,0 +1,109 @@
+import type { Base } from '../Base.js';
+import { AbstractManager } from './AbstractManager.js';
+export type EventManagerCallbackParams<T extends Event = Event> = {
+    event: T;
+    args: Array<any>;
+    index: number;
+    target: Element | Base | Promise<Base> | typeof window | typeof document | null;
+};
+/**
+ * Event management class.
+ *
+ * @todo Prevent binding of `onChildOrRefEvent` to the root element
+ * @todo Use event delegation?
+ */
+export declare class EventsManager extends AbstractManager {
+    __methodsCache: Map<string, string[]>;
+    /**
+     * Event listener object for the root element.
+     */
+    __rootElementHandler: EventListenerObject;
+    /**
+     * Event listener object for the root element.
+     *
+     * @type {EventListenerObject}
+     */
+    __documentHandler: {
+        /**
+         * @param  {Event|CustomEvent} event
+         * @return {void}
+         */
+        handleEvent: (event: any) => void;
+    };
+    /**
+     * Event listener object for the root element.
+     *
+     * @type {EventListenerObject}
+     */
+    __windowHandler: {
+        /**
+         * @param  {Event|CustomEvent} event
+         * @return {void}
+         */
+        handleEvent: (event: any) => void;
+    };
+    /**
+     * Event listener object for the refs.
+     */
+    __refsHandler: EventListenerObject;
+    /**
+     * Event listener object for the children.
+     */
+    __childrenHandler: EventListenerObject;
+    /**
+     * Class constructor.
+     */
+    constructor(base: Base);
+    /**
+     * Bind event methods to the given ref elements.
+     *
+     * @param {string} name
+     *   The name of the ref.
+     * @param {HTMLElement[]} elements
+     *   The elements of the ref.
+     * @return {void}
+     */
+    bindRef(name: string, elements: HTMLElement[]): void;
+    /**
+     * Bind event methods to the given ref elements.
+     *
+     * @param {string} name
+     *   The name of the ref.
+     * @param {HTMLElement[]} elements
+     *   The elements of the ref.
+     * @return {void}
+     */
+    unbindRef(name: string, elements: HTMLElement[]): void;
+    /**
+     * Bind event methods to the given child instance.
+     *
+     * @param {string} name
+     *   The name of the ref.
+     * @param {Base} instance
+     *   A base instance.
+     * @return {void}
+     */
+    bindChild(name: string, instance: Base): void;
+    /**
+     * Unbind event methods to the given child instance.
+     *
+     * @param {string} name
+     *   The name of the ref.
+     * @param {Base} instance
+     *   A base instance.
+     * @return {void}
+     */
+    unbindChild(name: string, instance: Base): void;
+    /**
+     * Bind event methods on the root element.
+     *
+     * @return {void}
+     */
+    bindRootElement(): void;
+    /**
+     * Unbind event method from the root element.
+     *
+     * @return {void}
+     */
+    unbindRootElement(): void;
+}

package/dist/Base/managers/EventsManager.js

@@ -0,0 +1,254 @@
+import { isArray } from "../../utils/is.js";
+import { dashCase, pascalCase } from "../../utils/string/changeCase.js";
+import { eventIsDefinedInConfig, eventIsNative, getEventTarget } from "../utils.js";
+import { getAllProperties } from "../../utils/object/getAllProperties.js";
+import { AbstractManager } from "./AbstractManager.js";
+import { normalizeRefName } from "./RefsManager.js";
+import { features } from "../features.js";
+const regexes = /* @__PURE__ */ new Map();
+function getRegex(regex) {
+  if (!regexes.has(regex)) {
+    regexes.set(regex, new RegExp(regex));
+  }
+  return regexes.get(regex);
+}
+function getEventNameByMethod(method, name = "") {
+  const regex = getRegex(`^on${pascalCase(name)}([A-Z].*)$`);
+  const [, event] = method.match(regex);
+  return dashCase(event);
+}
+function getEventMethodsByName(that, name = "") {
+  const regex = getRegex(`^on${pascalCase(name)}[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);
+  for (const method of methods) {
+    const event = getEventNameByMethod(method, name);
+    for (const element of elements) {
+      element?.[action](event, that.__refsHandler);
+    }
+  }
+}
+function manageChild(that, name, instance, mode = "add") {
+  const action = mode === "add" ? "$on" : "$off";
+  const methods = getEventMethodsByName(that, name);
+  const config = instance.__config;
+  for (const method of methods) {
+    const event = getEventNameByMethod(method, name);
+    if (getEventTarget(instance, event, config)) {
+      instance[action](event, that.__childrenHandler);
+    }
+  }
+}
+const isDocumentRegex = /^onDocument[A-Z][a-z]+/;
+const isWindowRegex = /^onWindow[A-Z][a-z]+/;
+const methodIsDocument = (method) => isDocumentRegex.test(method);
+const methodIsWindow = (method) => isWindowRegex.test(method);
+const methodIsGlobal = (method) => methodIsWindow(method) || methodIsDocument(method);
+const getGlobalEventTarget = (method) => methodIsDocument(method) ? document : window;
+function manageRootElement(that, mode = "add") {
+  const modeMethod = `${mode}EventListener`;
+  const methods = getEventMethodsByName(that);
+  const { __base: base, __config: config } = that;
+  for (const method of methods) {
+    let event = getEventNameByMethod(method);
+    if (methodIsGlobal(method)) {
+      event = getEventNameByMethod(method, methodIsDocument(method) ? "document" : "window");
+      const target = getGlobalEventTarget(method);
+      target[modeMethod](
+        event,
+        methodIsDocument(method) ? that.__documentHandler : that.__windowHandler
+      );
+    } else {
+      const target = getEventTarget(base, event, config);
+      target?.[modeMethod](event, that.__rootElementHandler);
+    }
+  }
+}
+function normalizeParams(params = {}) {
+  return {
+    event: null,
+    args: [],
+    index: 0,
+    target: null,
+    ...params
+  };
+}
+class EventsManager extends AbstractManager {
+  __methodsCache = /* @__PURE__ */ new Map();
+  /**
+   * Event listener object for the root element.
+   */
+  __rootElementHandler = {
+    handleEvent: (event) => {
+      const normalizedEventName = pascalCase(event.type);
+      const method = `on${normalizedEventName}`;
+      const isCustomEvent = event instanceof CustomEvent;
+      this.__base[method](
+        normalizeParams({
+          event,
+          args: isCustomEvent ? event.detail ?? [] : [],
+          target: isCustomEvent ? this.__base : this.__element
+        })
+      );
+    }
+  };
+  /**
+   * Event listener object for the root element.
+   *
+   * @type {EventListenerObject}
+   */
+  __documentHandler = {
+    /**
+     * @param  {Event|CustomEvent} event
+     * @return {void}
+     */
+    handleEvent: (event) => {
+      const normalizedEventName = pascalCase(event.type);
+      const method = `onDocument${normalizedEventName}`;
+      this.__base[method](normalizeParams({ event, target: document }));
+    }
+  };
+  /**
+   * Event listener object for the root element.
+   *
+   * @type {EventListenerObject}
+   */
+  __windowHandler = {
+    /**
+     * @param  {Event|CustomEvent} event
+     * @return {void}
+     */
+    handleEvent: (event) => {
+      const normalizedEventName = pascalCase(event.type);
+      const method = `onWindow${normalizedEventName}`;
+      this.__base[method](normalizeParams({ event, target: window }));
+    }
+  };
+  /**
+   * Event listener object for the refs.
+   */
+  __refsHandler = {
+    handleEvent: (event) => {
+      const ref = event.currentTarget;
+      const attributes = features.get("attributes");
+      const refName = normalizeRefName(ref.getAttribute(attributes.ref));
+      const normalizedRefName = pascalCase(refName);
+      const normalizedEventName = pascalCase(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](normalizeParams({ event, index, target: ref }));
+    }
+  };
+  /**
+   * Event listener object for the children.
+   */
+  __childrenHandler = {
+    handleEvent: (event) => {
+      const children = this.__base.__children.props;
+      for (const childName of Object.keys(children)) {
+        let index = -1;
+        for (const child of children[childName]) {
+          index++;
+          if (child.$el === event.currentTarget && (eventIsNative(event.type, child.$el) || eventIsDefinedInConfig(event.type, child.__config))) {
+            const normalizedEventName = pascalCase(event.type);
+            const normalizedChildName = pascalCase(childName);
+            const method = `on${normalizedChildName}${normalizedEventName}`;
+            const args = isArray(event.detail) ? event.detail : [];
+            this.__base[method](normalizeParams({ event, index, args, target: child }));
+          }
+        }
+      }
+    }
+  };
+  /**
+   * Class constructor.
+   */
+  constructor(base) {
+    super(base);
+  }
+  /**
+   * Bind event methods to the given ref elements.
+   *
+   * @param {string} name
+   *   The name of the ref.
+   * @param {HTMLElement[]} elements
+   *   The elements of the ref.
+   * @return {void}
+   */
+  bindRef(name, elements) {
+    manageRef(this, name, elements);
+  }
+  /**
+   * Bind event methods to the given ref elements.
+   *
+   * @param {string} name
+   *   The name of the ref.
+   * @param {HTMLElement[]} elements
+   *   The elements of the ref.
+   * @return {void}
+   */
+  unbindRef(name, elements) {
+    manageRef(this, name, elements, "remove");
+  }
+  /**
+   * Bind event methods to the given child instance.
+   *
+   * @param {string} name
+   *   The name of the ref.
+   * @param {Base} instance
+   *   A base instance.
+   * @return {void}
+   */
+  bindChild(name, instance) {
+    manageChild(this, name, instance);
+  }
+  /**
+   * Unbind event methods to the given child instance.
+   *
+   * @param {string} name
+   *   The name of the ref.
+   * @param {Base} instance
+   *   A base instance.
+   * @return {void}
+   */
+  unbindChild(name, instance) {
+    manageChild(this, name, instance, "remove");
+  }
+  /**
+   * Bind event methods on the root element.
+   *
+   * @return {void}
+   */
+  bindRootElement() {
+    manageRootElement(this);
+  }
+  /**
+   * Unbind event method from the root element.
+   *
+   * @return {void}
+   */
+  unbindRootElement() {
+    manageRootElement(this, "remove");
+  }
+}
+export {
+  EventsManager
+};
+//# sourceMappingURL=EventsManager.js.map

package/dist/Base/managers/EventsManager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../packages/js-toolkit/Base/managers/EventsManager.ts"],
+  "sourcesContent": ["import { isArray } from '../../utils/is.js';\nimport { dashCase, pascalCase } from '../../utils/string/changeCase.js';\nimport type { Base, BaseProps } from '../Base.js';\nimport { eventIsDefinedInConfig, eventIsNative, getEventTarget } from '../utils.js';\nimport { getAllProperties } from '../../utils/object/getAllProperties.js';\nimport { AbstractManager } from './AbstractManager.js';\nimport { normalizeRefName } from './RefsManager.js';\nimport { features } from '../features.js';\n\nconst regexes = new Map();\n\n/**\n * Get a regex with a cache;\n *\n * @param  {string} regex\n * @return {RegExp}\n */\nfunction getRegex(regex: string): RegExp {\n  if (!regexes.has(regex)) {\n    regexes.set(regex, new RegExp(regex));\n  }\n\n  return regexes.get(regex);\n}\n\n/**\n * Get the event name from the given method and its tied ref or children name.\n *\n * @param {string} method\n * @param {string} name\n * @return {string}\n * @private\n */\nfunction getEventNameByMethod(method: string, name = ''): string {\n  const regex = getRegex(`^on${pascalCase(name)}([A-Z].*)$`);\n  const [, event] = method.match(regex);\n  return dashCase(event);\n}\n\n/**\n * Get the base instance methods matching the `onSomething` pattern.\n *\n * @param {EventsManager} that\n * @param {string} [name]\n * @return {string[]}\n * @private\n */\n// eslint-disable-next-line no-use-before-define\nfunction getEventMethodsByName(that: EventsManager, name = ''): string[] {\n  const regex = getRegex(`^on${pascalCase(name)}[A-Z].*$`);\n  const key = regex.toString();\n\n  let methods = that.__methodsCache.get(key);\n\n  if (!methods) {\n    methods = Array.from(\n      getAllProperties(that.__base, [], (method) => regex.test(method)).reduce(\n        (set, [method]) => set.add(method),\n        new Set(),\n      ),\n    ) as string[];\n    that.__methodsCache.set(key, methods);\n  }\n\n  return methods;\n}\n\n/**\n * Manage a ref event methods.\n *\n * @param {EventsManager} that\n * @param  {string} name\n *   The name of the ref.\n * @param  {HTMLElement[]} elements\n *   The elements of the ref.\n * @param  {'add'|'remove'} [mode]\n *   The action to perform: add or remove the event listeners.\n * @return {void}\n * @private\n */\nfunction manageRef(\n  // eslint-disable-next-line no-use-before-define\n  that: EventsManager,\n  name: string,\n  elements: HTMLElement[],\n  mode: 'add' | 'remove' = 'add',\n) {\n  const action = `${mode}EventListener`;\n  const methods = getEventMethodsByName(that, name);\n  for (const method of methods) {\n    const event = getEventNameByMethod(method, name);\n    for (const element of elements) {\n      element?.[action](event, that.__refsHandler);\n    }\n  }\n}\n/**\n * Manage event methods to the given child instance.\n *\n * @param {EventsManager} that\n * @param {string} name\n *   The name of the ref.\n * @param {Base} instance\n *   A base instance.\n * @param {'add'|'remove'} [mode]\n *   The action to perform: add or remove the event listeners.\n * @return {void}\n * @private\n */\nfunction manageChild(\n  // eslint-disable-next-line no-use-before-define\n  that: EventsManager,\n  name: string,\n  instance: Base,\n  mode: 'add' | 'remove' = 'add',\n) {\n  const action = mode === 'add' ? '$on' : '$off';\n  const methods = getEventMethodsByName(that, name);\n  const config = instance.__config;\n  for (const method of methods) {\n    const event = getEventNameByMethod(method, name);\n    if (getEventTarget(instance, event, config)) {\n      instance[action](event, that.__childrenHandler);\n    }\n  }\n}\n\nconst isDocumentRegex = /^onDocument[A-Z][a-z]+/;\nconst isWindowRegex = /^onWindow[A-Z][a-z]+/;\nconst methodIsDocument = (method) => isDocumentRegex.test(method);\nconst methodIsWindow = (method) => isWindowRegex.test(method);\nconst methodIsGlobal = (method) => methodIsWindow(method) || methodIsDocument(method);\nconst getGlobalEventTarget = (method) => (methodIsDocument(method) ? document : window);\n\n/**\n * Manage event methods on the root element.\n *\n * @param {EventsManager} that\n * @param {'add'|'remove'} [mode]\n *   The action to perform: add or remove the event listeners, defaults to 'add'.\n * @return {void}\n * @private\n */\n// eslint-disable-next-line no-use-before-define\nfunction manageRootElement(that: EventsManager, mode: 'add' | 'remove' = 'add') {\n  const modeMethod = `${mode}EventListener`;\n  const methods = getEventMethodsByName(that);\n\n  const { __base: base, __config: config } = that;\n\n  for (const method of methods) {\n    let event = getEventNameByMethod(method);\n\n    if (methodIsGlobal(method)) {\n      event = getEventNameByMethod(method, methodIsDocument(method) ? 'document' : 'window');\n      const target = getGlobalEventTarget(method);\n      target[modeMethod](\n        event,\n        methodIsDocument(method) ? that.__documentHandler : that.__windowHandler,\n      );\n    } else {\n      const target = getEventTarget(base, event, config);\n      target?.[modeMethod](event, that.__rootElementHandler);\n    }\n  }\n}\n\nexport type EventManagerCallbackParams<T extends Event = Event> = {\n  event: T;\n  args: Array<any>;\n  index: number;\n  target: Element | Base | Promise<Base> | typeof window | typeof document | null;\n};\n\n/**\n * Normalize `on...` method params.\n */\nfunction normalizeParams(\n  params: Partial<EventManagerCallbackParams> = {},\n): EventManagerCallbackParams {\n  return {\n    event: null,\n    args: [],\n    index: 0,\n    target: null,\n    ...params,\n  };\n}\n\n/**\n * Event management class.\n *\n * @todo Prevent binding of `onChildOrRefEvent` to the root element\n * @todo Use event delegation?\n */\nexport class EventsManager extends AbstractManager {\n  __methodsCache: Map<string, string[]> = new Map();\n\n  /**\n   * Event listener object for the root element.\n   */\n  __rootElementHandler: EventListenerObject = {\n    handleEvent: (event: Event | CustomEvent) => {\n      const normalizedEventName = pascalCase(event.type);\n      const method = `on${normalizedEventName}`;\n      const isCustomEvent = event instanceof CustomEvent;\n\n      this.__base[method](\n        normalizeParams({\n          event,\n          args: isCustomEvent ? (event.detail ?? []) : [],\n          target: isCustomEvent ? this.__base : this.__element,\n        }),\n      );\n    },\n  };\n\n  /**\n   * Event listener object for the root element.\n   *\n   * @type {EventListenerObject}\n   */\n  __documentHandler = {\n    /**\n     * @param  {Event|CustomEvent} event\n     * @return {void}\n     */\n    handleEvent: (event) => {\n      const normalizedEventName = pascalCase(event.type);\n      const method = `onDocument${normalizedEventName}`;\n\n      this.__base[method](normalizeParams({ event, target: document }));\n    },\n  };\n\n  /**\n   * Event listener object for the root element.\n   *\n   * @type {EventListenerObject}\n   */\n  __windowHandler = {\n    /**\n     * @param  {Event|CustomEvent} event\n     * @return {void}\n     */\n    handleEvent: (event) => {\n      const normalizedEventName = pascalCase(event.type);\n      const method = `onWindow${normalizedEventName}`;\n\n      this.__base[method](normalizeParams({ event, target: window }));\n    },\n  };\n\n  /**\n   * Event listener object for the refs.\n   */\n  __refsHandler: EventListenerObject = {\n    handleEvent: (event) => {\n      const ref = event.currentTarget as HTMLElement;\n      const attributes = features.get('attributes');\n      const refName = normalizeRefName(ref.getAttribute(attributes.ref));\n\n      const normalizedRefName = pascalCase(refName);\n      const normalizedEventName = pascalCase(event.type);\n      const method = `on${normalizedRefName}${normalizedEventName}`;\n\n      let index = 0;\n      if (isArray(this.__base.$refs[refName])) {\n        index = (this.__base.$refs[refName] as HTMLElement[]).indexOf(ref);\n      }\n\n      this.__base[method](normalizeParams({ event, index, target: ref }));\n    },\n  };\n\n  /**\n   * Event listener object for the children.\n   */\n  __childrenHandler: EventListenerObject = {\n    handleEvent: (event: CustomEvent) => {\n      const children = this.__base.__children.props;\n\n      for (const childName of Object.keys(children)) {\n        let index = -1;\n\n        for (const child of children[childName] as Base<BaseProps>[]) {\n          index++;\n\n          if (\n            child.$el === event.currentTarget &&\n            (eventIsNative(event.type, child.$el) ||\n              eventIsDefinedInConfig(event.type, child.__config))\n          ) {\n            const normalizedEventName = pascalCase(event.type);\n            const normalizedChildName = pascalCase(childName);\n            const method = `on${normalizedChildName}${normalizedEventName}`;\n            const args = isArray(event.detail) ? event.detail : [];\n            this.__base[method](normalizeParams({ event, index, args, target: child }));\n          }\n        }\n      }\n    },\n  };\n\n  /**\n   * Class constructor.\n   */\n  constructor(base: Base) {\n    super(base);\n  }\n\n  /**\n   * Bind event methods to the given ref elements.\n   *\n   * @param {string} name\n   *   The name of the ref.\n   * @param {HTMLElement[]} elements\n   *   The elements of the ref.\n   * @return {void}\n   */\n  bindRef(name: string, elements: HTMLElement[]) {\n    manageRef(this, name, elements);\n  }\n\n  /**\n   * Bind event methods to the given ref elements.\n   *\n   * @param {string} name\n   *   The name of the ref.\n   * @param {HTMLElement[]} elements\n   *   The elements of the ref.\n   * @return {void}\n   */\n  unbindRef(name: string, elements: HTMLElement[]) {\n    manageRef(this, name, elements, 'remove');\n  }\n\n  /**\n   * Bind event methods to the given child instance.\n   *\n   * @param {string} name\n   *   The name of the ref.\n   * @param {Base} instance\n   *   A base instance.\n   * @return {void}\n   */\n  bindChild(name: string, instance: Base) {\n    manageChild(this, name, instance);\n  }\n\n  /**\n   * Unbind event methods to the given child instance.\n   *\n   * @param {string} name\n   *   The name of the ref.\n   * @param {Base} instance\n   *   A base instance.\n   * @return {void}\n   */\n  unbindChild(name: string, instance: Base) {\n    manageChild(this, name, instance, 'remove');\n  }\n\n  /**\n   * Bind event methods on the root element.\n   *\n   * @return {void}\n   */\n  bindRootElement() {\n    manageRootElement(this);\n  }\n\n  /**\n   * Unbind event method from the root element.\n   *\n   * @return {void}\n   */\n  unbindRootElement() {\n    manageRootElement(this, 'remove');\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}