tiny-essentials 1.26.3 → 1.26.4

package/dist/v1/libs/TinyClassManager.cjs

@@ -70,40 +70,111 @@ class TinyClassManager {
   }
 
   /**
-   * Applies a plugin to the class chain if all conditions are met.
+   * Internal helper to validate dependencies, check conflicts, and transition state.
    * @template {new (...args: any[]) => any} R
-   * @param {PluginDefinition<T, R>} plugin - The plugin module to be integrated.
-   * @returns {TinyClassManager<R>} A new manager instance holding the extended class chain.
-   * @throws {Error} Throws if instance is already consumed, plugin is duplicate, or dependencies are missing.
+   * @param {string} name - The plugin name.
+   * @param {string[]} deps - The plugin dependencies.
+   * @param {R} ExtendedClass - The newly extended class returned by the apply function.
+   * @returns {TinyClassManager<R>} A new manager instance.
    */
-  use(plugin) {
+  #validateAndTransition(name, deps, ExtendedClass) {
+    // Verifies if the current manager has already been consumed to prevent branching.
     if (this.#used) throw new Error(`[TinyClassManager] Cannot reuse a consumed manager instance.`);
-    if (this.#appliedPlugins.has(plugin.name))
-      throw new Error(`[TinyClassManager] Plugin conflict: "${plugin.name}" is already installed.`);
 
-    /**
-     * @type {string[]}
-     * Extracted dependencies array with fallback for undefined properties.
-     */
-    const deps = plugin.dependencies || [];
+    // Checks if the plugin being inserted is already in the applied list.
+    if (this.#appliedPlugins.has(name))
+      throw new Error(`[TinyClassManager] Plugin conflict: "${name}" is already installed.`);
 
     for (const dep of deps) {
       if (!this.#appliedPlugins.has(dep)) {
         throw new Error(
-          `[TinyClassManager] Missing Dependency: "${plugin.name}" requires "${dep}" to be installed first.`,
+          `[TinyClassManager] Missing Dependency: "${name}" requires "${dep}" to be installed first.`,
         );
       }
     }
 
-    const newClassManager = new TinyClassManager(plugin.apply(this.#currentClass));
-    this.#appliedPlugins.forEach((name) => newClassManager.#appliedPlugins.add(name));
-    newClassManager.#appliedPlugins.add(plugin.name);
+    /**
+     * @type {TinyClassManager<R>}
+     * The next manager instance wrapping the newly extended class chain.
+     */
+    const newClassManager = new TinyClassManager(ExtendedClass);
+
+    this.#appliedPlugins.forEach((appliedName) => newClassManager.#appliedPlugins.add(appliedName));
+    newClassManager.#appliedPlugins.add(name);
 
     this.#used = true;
     this.#appliedPlugins.clear();
+
     return newClassManager;
   }
 
+  /**
+   * Applies a plugin to the class chain using a definition object.
+   * @deprecated Use {@link insert} instead.
+   * @template {new (...args: any[]) => any} R
+   * @param {PluginDefinition<T, R>} plugin - The plugin module to be integrated.
+   * @returns {TinyClassManager<R>} A new manager instance holding the extended class chain.
+   * @throws {Error} Throws if instance is already consumed, plugin is duplicate, or dependencies are missing.
+   */
+  use(plugin) {
+    /**
+     * @type {string[]}
+     * Extracted dependencies array with fallback for undefined properties.
+     */
+    const deps = plugin.dependencies || [];
+
+    /**
+     * @type {R}
+     * The new class generated by the old object-style apply wrapper.
+     */
+    const ExtendedClass = plugin.apply(this.#currentClass);
+
+    return this.#validateAndTransition(plugin.name, deps, ExtendedClass);
+  }
+
+  /**
+   * Inserts a plugin directly by passing its apply function.
+   * It reads `_tinyDepName` and `_tinyDeps` statically from the returned class.
+   * @template {new (...args: any[]) => any} R
+   * @param {function(T): R} applyFn - Function that receives the base class and returns the extended class.
+   * @returns {TinyClassManager<R>} A new manager instance holding the extended class chain.
+   * @throws {Error} Throws if static properties are missing, instance is consumed, or validation fails.
+   */
+  insert(applyFn) {
+    /** * @type {R}
+     * The extended class returned directly from the provided function.
+     */
+    const ExtendedClass = applyFn(this.#currentClass);
+
+    /**
+     * @type {string}
+     * The plugin name extracted from the static property.
+     */
+    // @ts-ignore
+    const pluginName = ExtendedClass._tinyDepName;
+
+    if (!pluginName) {
+      throw new Error(
+        `[TinyClassManager] Plugin class must define a static '_tinyDepName' property.`,
+      );
+    }
+
+    /**
+     * @type {string[]}
+     * The dependencies extracted from the static property, defaulting to an empty array.
+     */
+    // @ts-ignore
+    const deps = ExtendedClass._tinyDeps ?? [];
+
+    if (!Array.isArray(deps) || !deps.every((name) => typeof name === 'string')) {
+      throw new Error(
+        `[TinyClassManager] Plugin class must define a static array of strings in '_tinyDepName' property.`,
+      );
+    }
+
+    return this.#validateAndTransition(pluginName, deps, ExtendedClass);
+  }
+
   /**
    * Finalizes the composition and returns the fully built class.
    * @returns {T} The final class representing the last extended version in the chain.

package/dist/v1/libs/TinyClassManager.d.mts

@@ -50,13 +50,23 @@ declare class TinyClassManager<T extends new (...args: any[]) => any> {
      */
     get used(): boolean;
     /**
-     * Applies a plugin to the class chain if all conditions are met.
+     * Applies a plugin to the class chain using a definition object.
+     * @deprecated Use {@link insert} instead.
      * @template {new (...args: any[]) => any} R
      * @param {PluginDefinition<T, R>} plugin - The plugin module to be integrated.
      * @returns {TinyClassManager<R>} A new manager instance holding the extended class chain.
      * @throws {Error} Throws if instance is already consumed, plugin is duplicate, or dependencies are missing.
      */
     use<R extends new (...args: any[]) => any>(plugin: PluginDefinition<T, R>): TinyClassManager<R>;
+    /**
+     * Inserts a plugin directly by passing its apply function.
+     * It reads `_tinyDepName` and `_tinyDeps` statically from the returned class.
+     * @template {new (...args: any[]) => any} R
+     * @param {function(T): R} applyFn - Function that receives the base class and returns the extended class.
+     * @returns {TinyClassManager<R>} A new manager instance holding the extended class chain.
+     * @throws {Error} Throws if static properties are missing, instance is consumed, or validation fails.
+     */
+    insert<R extends new (...args: any[]) => any>(applyFn: (arg0: T) => R): TinyClassManager<R>;
     /**
      * Finalizes the composition and returns the fully built class.
      * @returns {T} The final class representing the last extended version in the chain.

package/dist/v1/libs/TinyClassManager.mjs

@@ -59,33 +59,89 @@ class TinyClassManager {
         this.#currentClass = coreClass;
     }
     /**
-     * Applies a plugin to the class chain if all conditions are met.
+     * Internal helper to validate dependencies, check conflicts, and transition state.
+     * @template {new (...args: any[]) => any} R
+     * @param {string} name - The plugin name.
+     * @param {string[]} deps - The plugin dependencies.
+     * @param {R} ExtendedClass - The newly extended class returned by the apply function.
+     * @returns {TinyClassManager<R>} A new manager instance.
+     */
+    #validateAndTransition(name, deps, ExtendedClass) {
+        // Verifies if the current manager has already been consumed to prevent branching.
+        if (this.#used)
+            throw new Error(`[TinyClassManager] Cannot reuse a consumed manager instance.`);
+        // Checks if the plugin being inserted is already in the applied list.
+        if (this.#appliedPlugins.has(name))
+            throw new Error(`[TinyClassManager] Plugin conflict: "${name}" is already installed.`);
+        for (const dep of deps) {
+            if (!this.#appliedPlugins.has(dep)) {
+                throw new Error(`[TinyClassManager] Missing Dependency: "${name}" requires "${dep}" to be installed first.`);
+            }
+        }
+        /**
+         * @type {TinyClassManager<R>}
+         * The next manager instance wrapping the newly extended class chain.
+         */
+        const newClassManager = new TinyClassManager(ExtendedClass);
+        this.#appliedPlugins.forEach((appliedName) => newClassManager.#appliedPlugins.add(appliedName));
+        newClassManager.#appliedPlugins.add(name);
+        this.#used = true;
+        this.#appliedPlugins.clear();
+        return newClassManager;
+    }
+    /**
+     * Applies a plugin to the class chain using a definition object.
+     * @deprecated Use {@link insert} instead.
      * @template {new (...args: any[]) => any} R
      * @param {PluginDefinition<T, R>} plugin - The plugin module to be integrated.
      * @returns {TinyClassManager<R>} A new manager instance holding the extended class chain.
      * @throws {Error} Throws if instance is already consumed, plugin is duplicate, or dependencies are missing.
      */
     use(plugin) {
-        if (this.#used)
-            throw new Error(`[TinyClassManager] Cannot reuse a consumed manager instance.`);
-        if (this.#appliedPlugins.has(plugin.name))
-            throw new Error(`[TinyClassManager] Plugin conflict: "${plugin.name}" is already installed.`);
         /**
          * @type {string[]}
          * Extracted dependencies array with fallback for undefined properties.
          */
         const deps = plugin.dependencies || [];
-        for (const dep of deps) {
-            if (!this.#appliedPlugins.has(dep)) {
-                throw new Error(`[TinyClassManager] Missing Dependency: "${plugin.name}" requires "${dep}" to be installed first.`);
-            }
+        /**
+         * @type {R}
+         * The new class generated by the old object-style apply wrapper.
+         */
+        const ExtendedClass = plugin.apply(this.#currentClass);
+        return this.#validateAndTransition(plugin.name, deps, ExtendedClass);
+    }
+    /**
+     * Inserts a plugin directly by passing its apply function.
+     * It reads `_tinyDepName` and `_tinyDeps` statically from the returned class.
+     * @template {new (...args: any[]) => any} R
+     * @param {function(T): R} applyFn - Function that receives the base class and returns the extended class.
+     * @returns {TinyClassManager<R>} A new manager instance holding the extended class chain.
+     * @throws {Error} Throws if static properties are missing, instance is consumed, or validation fails.
+     */
+    insert(applyFn) {
+        /** * @type {R}
+         * The extended class returned directly from the provided function.
+         */
+        const ExtendedClass = applyFn(this.#currentClass);
+        /**
+         * @type {string}
+         * The plugin name extracted from the static property.
+         */
+        // @ts-ignore
+        const pluginName = ExtendedClass._tinyDepName;
+        if (!pluginName) {
+            throw new Error(`[TinyClassManager] Plugin class must define a static '_tinyDepName' property.`);
         }
-        const newClassManager = new TinyClassManager(plugin.apply(this.#currentClass));
-        this.#appliedPlugins.forEach((name) => newClassManager.#appliedPlugins.add(name));
-        newClassManager.#appliedPlugins.add(plugin.name);
-        this.#used = true;
-        this.#appliedPlugins.clear();
-        return newClassManager;
+        /**
+         * @type {string[]}
+         * The dependencies extracted from the static property, defaulting to an empty array.
+         */
+        // @ts-ignore
+        const deps = ExtendedClass._tinyDeps ?? [];
+        if (!Array.isArray(deps) || !deps.every((name) => typeof name === 'string')) {
+            throw new Error(`[TinyClassManager] Plugin class must define a static array of strings in '_tinyDepName' property.`);
+        }
+        return this.#validateAndTransition(pluginName, deps, ExtendedClass);
     }
     /**
      * Finalizes the composition and returns the fully built class.

package/dist/v1/libs/TinyEvents.cjs

@@ -264,6 +264,13 @@ class TinyEvents {
     this.#listeners.clear();
   }
 
+  /**
+   * Removes all event listeners of all types from the element.
+   */
+  removeAllListeners() {
+    return this.offAllTypes();
+  }
+
   /////////////////////////////////////////////
 
   /**

package/dist/v1/libs/TinyEvents.d.mts

@@ -101,6 +101,10 @@ declare class TinyEvents {
      * Removes all event listeners of all types from the element.
      */
     offAllTypes(): void;
+    /**
+     * Removes all event listeners of all types from the element.
+     */
+    removeAllListeners(): void;
     /**
      * Returns the number of listeners for a given event.
      *

package/dist/v1/libs/TinyEvents.mjs

@@ -244,6 +244,12 @@ class TinyEvents {
     offAllTypes() {
         this.#listeners.clear();
     }
+    /**
+     * Removes all event listeners of all types from the element.
+     */
+    removeAllListeners() {
+        return this.offAllTypes();
+    }
     /////////////////////////////////////////////
     /**
      * Returns the number of listeners for a given event.

package/dist/v1/libs/examples/TinyClassManager.cjs

@@ -15,57 +15,59 @@ class EntityCore {
 }
 
 // 2. Creating Dependent DLCs
-const Health = {
-  name: 'Health',
-  dependencies: [], // No dependencies, works just with the Core
-  /** @param {typeof EntityCore} Base */
-  apply: (Base) =>
-    class HealthModule extends Base {
-      /** @param {string} id */
-      constructor(id) {
-        super(id);
-        this.hp = 100;
-      }
+/** @param {typeof EntityCore} Base */
+const applyHealth = (Base) =>
+  class HealthModule extends Base {
+    static _tinyDepName = 'Health';
+    /** @type {string[]} */
+    static _tinyDeps = []; // No dependencies, works just with the Core
 
-      /**
-       * Deducts health from the entity.
-       * @param {number} amount - The amount of raw damage to deal.
-       */
-      takeDamage(amount) {
-        this.hp -= amount;
-        console.log(`Took ${amount} damage. HP left: ${this.hp}`);
-      }
-    },
-};
+    /** @param {string} id */
+    constructor(id) {
+      super(id);
+      this.hp = 100;
+    }
+
+    /**
+     * Deducts health from the entity.
+     * @param {number} amount - The amount of raw damage to deal.
+     */
+    takeDamage(amount) {
+      this.hp -= amount;
+      console.log(`Took ${amount} damage. HP left: ${this.hp}`);
+    }
+  };
 
 // 3. Creating Independent DLCs
-const Armor = {
-  name: 'Armor',
-  dependencies: ['Health'], // Strictly requires the Health module to be installed first
-  /** @param {ReturnType<typeof Health.apply>} Base */
-  apply: (Base) =>
-    class ArmorModule extends Base {
-      /** @param {string} id */
-      constructor(id) {
-        super(id);
-        this.armor = 50;
-      }
+/** @param {ReturnType<typeof applyHealth>} Base */
+const applyArmor = (Base) =>
+  class ArmorModule extends Base {
+    static _tinyDepName = 'Armor';
+    static _tinyDeps = ['Health']; // Strictly requires the Health module to be installed first
+
+    /** @param {string} id */
+    constructor(id) {
+      super(id);
+      this.armor = 50;
+    }
 
+    /**
+     * Deducts health, factoring in damage mitigation provided by armor.
+     * @param {number} amount - The initial damage before armor reduction.
+     */
+    takeDamage(amount) {
       /**
-       * Deducts health, factoring in damage mitigation provided by armor.
-       * @param {number} amount - The initial damage before armor reduction.
+       * Calculated damage after armor mitigation is applied, ensuring it never drops below 0.
        */
-      takeDamage(amount) {
-        const reducedDamage = Math.max(0, amount - this.armor * 0.1);
-        super.takeDamage(reducedDamage);
-      }
-    },
-};
+      const reducedDamage = Math.max(0, amount - this.armor * 0.1);
+      super.takeDamage(reducedDamage);
+    }
+  };
 
 // 4. Building the final class
 try {
   const CoreTest = new TinyClassManager(EntityCore);
-  const FullyArmoredEntity = CoreTest.use(Health).use(Armor).build();
+  const FullyArmoredEntity = CoreTest.insert(applyHealth).insert(applyArmor).build();
 
   const myEntity = new FullyArmoredEntity('Player_1');
   myEntity.takeDamage(30);

package/dist/v1/libs/examples/TinyClassManager.mjs

@@ -10,51 +10,51 @@ class EntityCore {
     }
 }
 // 2. Creating Dependent DLCs
-const Health = {
-    name: 'Health',
-    dependencies: [], // No dependencies, works just with the Core
-    /** @param {typeof EntityCore} Base */
-    apply: (Base) => class HealthModule extends Base {
-        /** @param {string} id */
-        constructor(id) {
-            super(id);
-            this.hp = 100;
-        }
-        /**
-         * Deducts health from the entity.
-         * @param {number} amount - The amount of raw damage to deal.
-         */
-        takeDamage(amount) {
-            this.hp -= amount;
-            console.log(`Took ${amount} damage. HP left: ${this.hp}`);
-        }
-    },
+/** @param {typeof EntityCore} Base */
+const applyHealth = (Base) => class HealthModule extends Base {
+    static _tinyDepName = 'Health';
+    /** @type {string[]} */
+    static _tinyDeps = []; // No dependencies, works just with the Core
+    /** @param {string} id */
+    constructor(id) {
+        super(id);
+        this.hp = 100;
+    }
+    /**
+     * Deducts health from the entity.
+     * @param {number} amount - The amount of raw damage to deal.
+     */
+    takeDamage(amount) {
+        this.hp -= amount;
+        console.log(`Took ${amount} damage. HP left: ${this.hp}`);
+    }
 };
 // 3. Creating Independent DLCs
-const Armor = {
-    name: 'Armor',
-    dependencies: ['Health'], // Strictly requires the Health module to be installed first
-    /** @param {ReturnType<typeof Health.apply>} Base */
-    apply: (Base) => class ArmorModule extends Base {
-        /** @param {string} id */
-        constructor(id) {
-            super(id);
-            this.armor = 50;
-        }
+/** @param {ReturnType<typeof applyHealth>} Base */
+const applyArmor = (Base) => class ArmorModule extends Base {
+    static _tinyDepName = 'Armor';
+    static _tinyDeps = ['Health']; // Strictly requires the Health module to be installed first
+    /** @param {string} id */
+    constructor(id) {
+        super(id);
+        this.armor = 50;
+    }
+    /**
+     * Deducts health, factoring in damage mitigation provided by armor.
+     * @param {number} amount - The initial damage before armor reduction.
+     */
+    takeDamage(amount) {
         /**
-         * Deducts health, factoring in damage mitigation provided by armor.
-         * @param {number} amount - The initial damage before armor reduction.
+         * Calculated damage after armor mitigation is applied, ensuring it never drops below 0.
          */
-        takeDamage(amount) {
-            const reducedDamage = Math.max(0, amount - this.armor * 0.1);
-            super.takeDamage(reducedDamage);
-        }
-    },
+        const reducedDamage = Math.max(0, amount - this.armor * 0.1);
+        super.takeDamage(reducedDamage);
+    }
 };
 // 4. Building the final class
 try {
     const CoreTest = new TinyClassManager(EntityCore);
-    const FullyArmoredEntity = CoreTest.use(Health).use(Armor).build();
+    const FullyArmoredEntity = CoreTest.insert(applyHealth).insert(applyArmor).build();
     const myEntity = new FullyArmoredEntity('Player_1');
     myEntity.takeDamage(30);
     console.log(`Armor value: ${myEntity.armor}`);