@studiometa/js-toolkit 2.4.4-alpha.1 → 2.4.4-alpha.4

package/Base/index.cjs

@@ -27,10 +27,10 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/Base/index.js
+// packages/js-toolkit/Base/index.ts
 var Base_exports = {};
 __export(Base_exports, {
-  default: () => Base
+  Base: () => Base
 });
 module.exports = __toCommonJS(Base_exports);
 var import_utils = require("./utils.cjs");

package/Base/index.d.ts

@@ -1,207 +1,141 @@
-/**
- * @typedef {typeof Base} BaseConstructor
- * @typedef {(Base) => Promise<BaseConstructor | { default: BaseConstructor }>} BaseAsyncConstructor
- * @typedef {{ [name:string]: any }} BaseOptions
- * @typedef {{ [name:string]: HTMLElement | HTMLElement[] }} BaseRefs
- * @typedef {{ [nameOrSelector:string]: Base[] | Promise<Base>[] }} BaseChildren
- * @typedef {{ [nameOrSelector:string]: BaseConstructor | BaseAsyncConstructor }} BaseConfigComponents
- * @typedef {import('./managers/OptionsManager').OptionsSchema} BaseConfigOptions
- * @typedef {import('./managers/ServicesManager.js').ServiceName} ServiceName
- */
-/**
- * @typedef {Object} BaseConfig
- * @property {string} name
- * @property {boolean} [debug]
- * @property {boolean} [log]
- * @property {string[]} [refs]
- * @property {string[]} [emits]
- * @property {BaseConfigComponents} [components]
- * @property {BaseConfigOptions} [options]
- */
-/**
- * @typedef {{
- *   $el?: HTMLElement,
- *   $options?: BaseOptions,
- *   $refs?: BaseRefs,
- *   $children?: { [name:string]: Base | Promise<Base> },
- * }} BaseTypeParameter
- */
-/**
- * @typedef {Object} Managers
- * @property {typeof ChildrenManager} ChildrenManager
- * @property {typeof EventsManager} EventsManager
- * @property {typeof OptionsManager} OptionsManager
- * @property {typeof RefsManager} RefsManager
- * @property {typeof ServicesManager} ServicesManager
- */
+import ChildrenManager from './managers/ChildrenManager.js';
+import RefsManager from './managers/RefsManager.js';
+import ServicesManager from './managers/ServicesManager.js';
+import EventsManager from './managers/EventsManager.js';
+import OptionsManager from './managers/OptionsManager.js';
+export declare type BaseEl = HTMLElement & {
+    __base__?: WeakMap<BaseConstructor, Base | 'terminated'>;
+};
+export declare type BaseConstructor<T extends Base = Base> = {
+    new (...args: any[]): T;
+    prototype: Base;
+} & Pick<typeof Base, keyof typeof Base>;
+export declare type BaseAsyncConstructor<T extends Base = Base> = (Base: any) => Promise<BaseConstructor<T> | {
+    default: BaseConstructor<T>;
+}>;
+export declare type BaseOptions = {
+    [name: string]: unknown;
+};
+export declare type BaseRefs = {
+    [name: string]: HTMLElement | HTMLElement[];
+};
+export declare type BaseChildren = {
+    [nameOrSelector: string]: Base[] | Promise<Base>[];
+};
+export declare type BaseConfigComponents = {
+    [nameOrSelector: string]: BaseConstructor | BaseAsyncConstructor;
+};
+export declare type BaseConfig = {
+    name: string;
+    debug?: boolean;
+    log?: boolean;
+    refs?: string[];
+    emits?: string[];
+    components?: BaseConfigComponents;
+    options?: import('./managers/OptionsManager').OptionsSchema;
+};
+export declare type BaseTypeParameter = {
+    $el?: HTMLElement;
+    $options?: BaseOptions;
+    $refs?: BaseRefs;
+    $children?: BaseChildren;
+};
+export declare type Managers = {
+    ChildrenManager: typeof ChildrenManager;
+    EventsManager: typeof EventsManager;
+    OptionsManager: typeof OptionsManager;
+    RefsManager: typeof RefsManager;
+    ServicesManager: typeof ServicesManager;
+};
 /**
  * Base class.
- * @template {BaseTypeParameter} [BaseInterface={ $el: HTMLElement, $options: BaseOptions, $refs: BaseRefs, $children: { [name:string]: Base | Promise<Base> } }]
  */
-export default class Base<BaseInterface extends BaseTypeParameter = {
-    $el: HTMLElement;
-    $options: BaseOptions;
-    $refs: BaseRefs;
-    $children: {
-        [name: string]: Base<any> | Promise<Base<any>>;
-    };
-}> extends EventTarget {
+export declare class Base<T extends BaseTypeParameter = BaseTypeParameter> extends EventTarget {
     /**
      * This is a Base instance.
-     * @type {boolean}
-     * @readonly
-     */
-    static readonly $isBase: boolean;
-    /**
-     * @type {BaseConfig}
-     */
-    static config: BaseConfig;
-    /**
-     * Factory method to generate multiple instance of the class.
-     *
-     * @param  {string}      nameOrSelector The selector on which to mount each instance.
-     * @returns {Array<Base>}                A list of the created instance.
-     */
-    static $factory(nameOrSelector: string): Array<Base>;
-    /**
-     * Class constructor where all the magic takes place.
-     *
-     * @param {HTMLElement} element The component's root element dd.
      */
-    constructor(element: HTMLElement);
+    static readonly $isBase: true;
     /**
      * The instance parent.
-     * @type {Base}
      */
     $parent: Base;
     /**
      * The instance id.
-     * @type {string}
      */
     $id: string;
     /**
      * The root element.
-     * @type {BaseInterface['$el'] & HTMLElement & { __base__?: WeakMap<BaseConstructor, Base | 'terminated'> }}
      */
-    $el: BaseInterface['$el'] & HTMLElement & {
-        __base__?: WeakMap<BaseConstructor, Base | 'terminated'>;
-    };
+    $el: T['$el'] & BaseEl;
     /**
      * The state of the component.
-     * @type {boolean}
      */
     $isMounted: boolean;
     /**
      * Store the event handlers.
-     *
-     * @type {Map<string, Set<EventListenerOrEventListenerObject>>}
      */
     __eventHandlers: Map<string, Set<EventListenerOrEventListenerObject>>;
     /**
      * Get the root instance of the app.
-     * @returns {Base}
      */
-    get $root(): Base<{
-        $el: HTMLElement;
-        $options: BaseOptions;
-        $refs: BaseRefs;
-        $children: {
-            [name: string]: Base<any> | Promise<Base<any>>;
-        };
-    }>;
+    get $root(): Base;
     /**
      * Merge configuration with the parents' configurations.
-     *
-     * @returns {BaseConfig}
      */
     get __config(): BaseConfig;
-    /**
-     * @type {ServicesManager}
-     */
+    static config: BaseConfig;
     __services: ServicesManager;
-    /**
-     * @type {ServicesManager}
-     */
     get $services(): ServicesManager;
-    /**
-     * @type {RefsManager & BaseInterface['$refs'] & BaseRefs}
-     */
-    __refs: RefsManager & BaseInterface['$refs'] & BaseRefs;
-    /**
-     * @returns {RefsManager & BaseInterface['$refs'] & BaseRefs}
-     */
-    get $refs(): RefsManager & BaseInterface["$refs"] & BaseRefs;
-    /**
-     * @type {OptionsManager & BaseInterface['$options'] & BaseOptions}
-     */
-    __options: OptionsManager & BaseInterface['$options'] & BaseOptions;
-    /**
-     * @returns {OptionsManager & BaseInterface['$options'] & BaseOptions}
-     */
-    get $options(): OptionsManager & BaseInterface["$options"] & BaseOptions;
-    /**
-     * @type {ChildrenManager & { [key in keyof BaseInterface['$children']]: Array<BaseInterface['$children'][key]> } & BaseChildren}
-     */
-    __children: ChildrenManager & (BaseInterface["$children"] extends infer T ? { [key in keyof T]: BaseInterface["$children"][key][]; } : never) & BaseChildren;
-    /**
-     * @returns {ChildrenManager & { [key in keyof BaseInterface['$children']]: Array<BaseInterface['$children'][key]> } & BaseChildren}
-     */
-    get $children(): ChildrenManager & (BaseInterface["$children"] extends infer T_1 ? { [key_1 in keyof T_1]: BaseInterface["$children"][key_1][]; } : never) & BaseChildren;
-    /**
-     * @type {EventsManager}
-     */
+    __refs: RefsManager & T['$refs'] & BaseRefs;
+    get $refs(): RefsManager & T['$refs'] & BaseRefs;
+    __options: OptionsManager & T['$options'] & BaseOptions;
+    get $options(): OptionsManager & T['$options'] & BaseOptions;
+    __children: ChildrenManager & T['$children'] & BaseChildren;
+    get $children(): ChildrenManager & T['$children'] & BaseChildren;
     __events: EventsManager;
     /**
      * Small helper to log stuff.
-     *
-     * @returns {(...args: any) => void}
      */
-    get $log(): (...args: any) => void;
+    get $log(): (...args: unknown[]) => void;
     /**
      * Small helper to debug information.
-     *
-     * @returns {(...args:any) => void}
      */
-    get __debug(): (...args: any) => void;
+    get __debug(): (...args: unknown[]) => void;
     /**
      * Get manager constructors.
-     *
-     * @returns {Managers}
      */
     get __managers(): Managers;
     /**
      * Call an instance method and emit corresponding events.
-     *
-     * @param {string} method
-     * @param {any[]} args
-     * @returns {any}
      */
-    __callMethod(method: string, ...args: any[]): any;
+    __callMethod(method: string, ...args: unknown[]): unknown;
     /**
      * Test if the given event has been bound to the instance.
      *
-     * @param  {string} event The event's name.
+     * @param   {string} event The event's name.
      * @returns {boolean}      Wether the given event has been bound or not.
      */
     __hasEvent(event: string): boolean;
+    /**
+     * Class constructor where all the magic takes place.
+     *
+     * @param {HTMLElement} element The component's root element dd.
+     */
+    constructor(element: HTMLElement);
     /**
      * Trigger the `mounted` callback.
-     * @returns {this}
      */
     $mount(): this;
     /**
      * Update the instance children.
-     * @returns {this}
      */
     $update(): this;
     /**
      * Trigger the `destroyed` callback.
-     * @returns {this}
      */
     $destroy(): this;
     /**
      * Terminate a child instance when it is not needed anymore.
-     * @returns {void}
      */
     $terminate(): void;
     /**
@@ -220,10 +154,8 @@ export default class Base<BaseInterface extends BaseTypeParameter = {
     __removeEmits(event: string): void;
     /**
      * Get the instance constructor.
-     *
-     * @returns {BaseConstructor}
      */
-    get __ctor(): typeof Base;
+    get __ctor(): BaseConstructor;
     /**
      * Bind a listener function to an event.
      *
@@ -252,85 +184,13 @@ export default class Base<BaseInterface extends BaseTypeParameter = {
     /**
      * Emits an event.
      *
-     * @param  {string} event
-     *   Name of the event.
-     * @param  {any[]}        args  The arguments to apply to the functions bound to this event.
+     * @param  {string} event Name of the event.
+     * @param  {any[]}  args  The arguments to apply to the functions bound to this event.
      * @returns {void}
      */
-    $emit(event: string, ...args: any[]): void;
+    $emit(event: string, ...args: unknown[]): void;
+    /**
+     * Factory method to generate multiple instance of the class.
+     */
+    static $factory(nameOrSelector: string): Base[];
 }
-export type BaseConstructor = typeof Base;
-export type BaseAsyncConstructor = (Base: any) => Promise<BaseConstructor | {
-    default: BaseConstructor;
-}>;
-export type BaseOptions = {
-    [name: string]: any;
-};
-export type BaseRefs = {
-    [name: string]: HTMLElement | HTMLElement[];
-};
-export type BaseChildren = {
-    [nameOrSelector: string]: Base<{
-        $el: HTMLElement;
-        $options: BaseOptions;
-        $refs: BaseRefs;
-        $children: {
-            [name: string]: Base<any> | Promise<Base<any>>;
-        };
-    }>[] | Promise<Base<{
-        $el: HTMLElement;
-        $options: BaseOptions;
-        $refs: BaseRefs;
-        $children: {
-            [name: string]: Base<any> | Promise<Base<any>>;
-        };
-    }>>[];
-};
-export type BaseConfigComponents = {
-    [nameOrSelector: string]: typeof Base | BaseAsyncConstructor;
-};
-export type BaseConfigOptions = import('./managers/OptionsManager').OptionsSchema;
-export type ServiceName = import('./managers/ServicesManager.js').ServiceName;
-export type BaseConfig = {
-    name: string;
-    debug?: boolean;
-    log?: boolean;
-    refs?: string[];
-    emits?: string[];
-    components?: BaseConfigComponents;
-    options?: BaseConfigOptions;
-};
-export type BaseTypeParameter = {
-    $el?: HTMLElement;
-    $options?: BaseOptions;
-    $refs?: BaseRefs;
-    $children?: {
-        [name: string]: Base<{
-            $el: HTMLElement;
-            $options: BaseOptions;
-            $refs: BaseRefs;
-            $children: {
-                [name: string]: Base<any> | Promise<Base<any>>;
-            };
-        }> | Promise<Base<{
-            $el: HTMLElement;
-            $options: BaseOptions;
-            $refs: BaseRefs;
-            $children: {
-                [name: string]: Base<any> | Promise<Base<any>>;
-            };
-        }>>;
-    };
-};
-export type Managers = {
-    ChildrenManager: typeof ChildrenManager;
-    EventsManager: typeof EventsManager;
-    OptionsManager: typeof OptionsManager;
-    RefsManager: typeof RefsManager;
-    ServicesManager: typeof ServicesManager;
-};
-import ServicesManager from "./managers/ServicesManager.js";
-import RefsManager from "./managers/RefsManager.js";
-import OptionsManager from "./managers/OptionsManager.js";
-import ChildrenManager from "./managers/ChildrenManager.js";
-import EventsManager from "./managers/EventsManager.js";

package/Base/index.js

@@ -289,5 +289,5 @@ __publicField(Base, "config", {
   ]
 });
 export {
-  Base as default
+  Base
 };

package/Base/managers/AbstractManager.d.ts

@@ -1,5 +1,5 @@
 /**
- * @typedef {import('../index.js').default} Base
+ * @typedef {import('../index.js').Base} Base
  * @typedef {import('../index.js').BaseConfig} BaseConfig
  * @typedef {import('./EventsManager.js').default} EventsManager
  */
@@ -39,6 +39,6 @@ export default class AbstractManager {
      */
     __hideProperties(properties: string[]): void;
 }
-export type Base = import('../index.js').default;
+export type Base = import('../index.js').Base;
 export type BaseConfig = import('../index.js').BaseConfig;
 export type EventsManager = import('./EventsManager.js').default;

package/Base/managers/ChildrenManager.cjs

@@ -27,7 +27,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/Base/managers/ChildrenManager.js
+// packages/js-toolkit/Base/managers/ChildrenManager.ts
 var ChildrenManager_exports = {};
 __export(ChildrenManager_exports, {
   default: () => ChildrenManager
@@ -36,9 +36,7 @@ module.exports = __toCommonJS(ChildrenManager_exports);
 var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
 var import_utils = require("../utils.cjs");
 function __getChild(that, el, ComponentClass, name) {
-  const asyncComponentPromise = that.__asyncComponentPromises.get(
-    ComponentClass
-  );
+  const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
   if ("$isBase" in ComponentClass || asyncComponentPromise && asyncComponentPromise.status === "resolved") {
     let ctor = ComponentClass;
     if (asyncComponentPromise) {

package/Base/managers/ChildrenManager.d.ts

@@ -1,3 +1,5 @@
+import type { BaseConstructor, BaseAsyncConstructor } from '../index.js';
+import AbstractManager from './AbstractManager.js';
 /**
  * Children manager.
  */
@@ -5,17 +7,12 @@ 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.
-     *
-     * @type {WeakMap<BaseAsyncConstructor, { promise: ReturnType<BaseAsyncConstructor>, status: 'pending'|'resolved', ctor?: BaseConstructor }>}
      */
     __asyncComponentPromises: WeakMap<BaseAsyncConstructor, {
         promise: ReturnType<BaseAsyncConstructor>;
         status: 'pending' | 'resolved';
         ctor?: BaseConstructor;
     }>;
-    /**
-     * @returns {string[]}
-     */
     get registeredNames(): string[];
     /**
      * Register instances of all children components.
@@ -34,8 +31,3 @@ export default class ChildrenManager extends AbstractManager {
      */
     destroyAll(): void;
 }
-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;
-import AbstractManager from "./AbstractManager.js";

package/Base/managers/ChildrenManager.js

@@ -7,9 +7,7 @@ var __publicField = (obj, key, value) => {
 import AbstractManager from "./AbstractManager.js";
 import { getComponentElements } from "../utils.js";
 function __getChild(that, el, ComponentClass, name) {
-  const asyncComponentPromise = that.__asyncComponentPromises.get(
-    ComponentClass
-  );
+  const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
   if ("$isBase" in ComponentClass || asyncComponentPromise && asyncComponentPromise.status === "resolved") {
     let ctor = ComponentClass;
     if (asyncComponentPromise) {

package/Base/managers/EventsManager.cjs

@@ -27,7 +27,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/Base/managers/EventsManager.js
+// packages/js-toolkit/Base/managers/EventsManager.ts
 var EventsManager_exports = {};
 __export(EventsManager_exports, {
   default: () => EventsManager,
@@ -143,14 +143,14 @@ var EventsManager = class extends import_AbstractManager.default {
         const childrenManager = this.__base.$children;
         const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
           name: childName,
-          child: childrenManager[childName].find(
+          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 index = [...childrenManager[name]].indexOf(resolvedChild);
         const args = (0, import_utils.isArray)(event.detail) ? event.detail : [];
         this.__base[method](...args, index, event);
       }

package/Base/managers/EventsManager.d.ts

@@ -1,3 +1,5 @@
+import type { Base } from '../index.js';
+import AbstractManager from './AbstractManager.js';
 /**
  * Normalize the given name to PascalCase, such as:
  *
@@ -18,42 +20,37 @@
  * @param {string} name
  * @returns {string}
  */
-export function normalizeName(name: string): string;
+export declare function normalizeName(name: string): string;
 /**
  * Normalize the event names from PascalCase to kebab-case.
  *
  * @param {string} name
  * @returns {string}
  */
-export function normalizeEventName(name: string): string;
+export declare function normalizeEventName(name: string): string;
 /**
  * Event management class.
  * @todo Prevent binding of `onChildOrRefEvent` to the root element
  * @todo Use event delegation?
  */
 export default class EventsManager extends AbstractManager {
-    /**
-     * @type {WeakMap}
-     */
-    __methodsCache: WeakMap<any, any>;
+    __methodsCache: Map<string, string[]>;
     /**
      * Event listener object for the root element.
-     *
-     * @type {EventListenerObject}
      */
     __rootElementHandler: EventListenerObject;
     /**
      * Event listener object for the refs.
-     *
-     * @type {EventListenerObject}
      */
     __refsHandler: EventListenerObject;
     /**
      * Event listener object for the children.
-     *
-     * @type {EventListenerObject}
      */
     __childrenHandler: EventListenerObject;
+    /**
+     * Class constructor.
+     */
+    constructor(base: Base);
     /**
      * Bind event methods to the given ref elements.
      *
@@ -107,6 +104,3 @@ export default class EventsManager extends AbstractManager {
      */
     unbindRootElement(): void;
 }
-export type Base = import('../index.js').default;
-export type ChildrenManager = import('./ChildrenManager.js').default;
-import AbstractManager from "./AbstractManager.js";

package/Base/managers/EventsManager.js

@@ -112,14 +112,14 @@ class EventsManager extends AbstractManager {
         const childrenManager = this.__base.$children;
         const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
           name: childName,
-          child: childrenManager[childName].find(
+          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 index = [...childrenManager[name]].indexOf(resolvedChild);
         const args = isArray(event.detail) ? event.detail : [];
         this.__base[method](...args, index, event);
       }

package/Base/managers/OptionsManager.d.ts

@@ -52,7 +52,7 @@ export default class OptionsManager extends AbstractManager {
     set(name: string, value: any, config: OptionObject): void;
 }
 export type DeepmergeOptions = import('deepmerge').Options;
-export type Base = import('../index.js').default;
+export type Base = import('../index.js').Base;
 export type BaseConfig = import('../index.js').BaseConfig;
 export type OptionType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
 export type ArrayOption = {

package/Base/managers/ServicesManager.d.ts

@@ -79,7 +79,7 @@ export default class ServicesManager extends AbstractManager {
      */
     unregister(name: string): void;
 }
-export type Base = import('../index').default;
+export type Base = import('../index').Base;
 export type BaseConstructor = import('../index').BaseConstructor;
 export type ServiceInterface = import('../../services').ServiceInterface<any>;
 export type Services = typeof SERVICES_MAP & Record<string, () => import("../../services").ServiceInterface<any>>;

package/Base/types.cjs

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/js-toolkit/Base/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+if (module.exports.default) module.exports = module.exports.default;