tiny-essentials 1.26.3 → 1.26.4

package/docs/v1/libs/TinyClassManager.md

@@ -6,9 +6,10 @@ Welcome to **TinyClassManager**! This is a lightweight, linear mixin manager des
 
 ## 🚀 Key Features
 
-* **🔒 Immutable Chain State:** Each `.use()` call consumes the previous manager, preventing unwanted side effects or weird mutations.
+* **🔒 Immutable Chain State:** Each `.insert()` call consumes the previous manager, preventing unwanted side effects or weird mutations.
 * **🧩 Dependency Verification:** Automatically ensures that a required plugin is loaded before the dependent plugin is applied.
 * **🛑 Conflict Protection:** Prevents you from installing the exact same plugin twice on the same class chain.
+* **⚡ Clean Architecture:** Uses static class properties to manage metadata, keeping your plugin functions pure and direct.
 
 ---
 
@@ -25,8 +26,9 @@ Welcome to **TinyClassManager**! This is a lightweight, linear mixin manager des
 
 #### Methods
 
-* **`constructor(coreClass)`**: Initialises the manager with your foundational core class.
-* **`use(plugin)`**: Applies a new plugin to the chain. Returns a *new* `TinyClassManager` instance containing the extended class.
+* **`constructor(coreClass)`**: Initializes the manager with your foundational core class.
+* **`insert(applyFn)`**: Applies a new plugin to the chain by passing a function that returns the extended class. The returned class **must** define a `static _tinyDepName` string, and can optionally define a `static _tinyDeps` array of strings. Returns a *new* `TinyClassManager` instance.
+* **`use(plugin)`**: *[Deprecated]* Legacy method for applying plugins using a definition object. Use `insert` instead.
 * **`build()`**: Finalizes the composition chain, marks the instance as consumed, and returns the fully compiled class ready for instantiation.
 
 ---
@@ -57,84 +59,81 @@ class EntityCore {
 
 ### Step 2: Create an Independent Module 🏷️
 
-Now, let's create our first module. A plugin is just a plain object with three specific keys: `name`, `dependencies`, and `apply`. This module doesn't depend on anything else, so its dependencies array is empty.
+Now, let's create our first module. A plugin is a function that receives the base class and returns an extended version of it. We use static properties (`_tinyDepName` and `_tinyDeps`) to tell the manager what this plugin is and what it needs. This module doesn't depend on anything else, so its dependencies array is empty.
 
 ```javascript
-const Health = {
-  name: 'Health',
-  dependencies: [], // Works fine straight out of the box with the Core
-  
-  /**
-   * @param {typeof EntityCore} Base - The incoming base class to extend.
-   */
-  apply: (Base) =>
-    class HealthModule extends Base {
-      /**
-       * @param {string} id
-       */
-      constructor(id) {
-        super(id); // Always remember to pass arguments down!
-        
-        /** @type {number} */
-        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 - The incoming base class to extend.
+ */
+const applyHealth = (Base) =>
+  class HealthModule extends Base {
+    static _tinyDepName = 'Health';
+    /** @type {string[]} */
+    static _tinyDeps = []; // Works fine straight out of the box with the Core
+
+    /**
+     * @param {string} id
+     */
+    constructor(id) {
+      super(id); // Always remember to pass arguments down!
+      
+      /** @type {number} */
+      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}`);
+    }
+  };
 
 ```
 
 ### Step 3: Create a Dependent Module 🛡️
 
-Here is where the magic happens! The `Armor` module strictly requires the `Health` module to be loaded first because it relies on overriding the `takeDamage` logic. We enforce this relationship inside the `dependencies` array.
+Here is where the magic happens! The `Armor` module strictly requires the `Health` module to be loaded first because it relies on overriding the `takeDamage` logic. We enforce this relationship inside the `static _tinyDeps` array.
 
 ```javascript
-const Armor = {
-  name: 'Armor',
-  dependencies: ['Health'], // Strictly requires the "Health" module!
-  
-  /**
-   * @param {ReturnType<typeof Health.apply>} Base - The class containing Health features.
-   */
-  apply: (Base) =>
-    class ArmorModule extends Base {
-      /**
-       * @param {string} id
-       */
-      constructor(id) {
-        super(id);
-        
-        /** @type {number} */
-        this.armor = 50;
-      }
-
-      /**
-       * Deducts health, factoring in damage mitigation provided by armor.
-       * @param {number} amount - The initial damage before armor reduction.
-       */
-      takeDamage(amount) {
-        // Mitigates damage using the armor stat
-        const reducedDamage = Math.max(0, amount - this.armor * 0.1);
-        
-        // Pass the mitigated damage up to the Health layer
-        super.takeDamage(reducedDamage);
-      }
-    },
-};
+/**
+ * @param {ReturnType<typeof applyHealth>} Base - The class containing Health features.
+ */
+const applyArmor = (Base) =>
+  class ArmorModule extends Base {
+    static _tinyDepName = 'Armor';
+    static _tinyDeps = ['Health']; // Strictly requires the "Health" module!
+
+    /**
+     * @param {string} id
+     */
+    constructor(id) {
+      super(id);
+      
+      /** @type {number} */
+      this.armor = 50;
+    }
+
+    /**
+     * Deducts health, factoring in damage mitigation provided by armor.
+     * @param {number} amount - The initial damage before armor reduction.
+     */
+    takeDamage(amount) {
+      // Mitigates damage using the armor stat
+      const reducedDamage = Math.max(0, amount - this.armor * 0.1);
+      
+      // Pass the mitigated damage up to the Health layer
+      super.takeDamage(reducedDamage);
+    }
+  };
 
 ```
 
 ### Step 4: Chain and Build Your Custom Class 🏗️
 
-Finally, use the manager to safely piece your modules together. Remember that `TinyClassManager` uses an explosive state pattern: once you run `.use()` or `.build()`, that specific instance is closed, forcing you to use the new returned chain instance.
+Finally, use the manager to safely piece your modules together. Remember that `TinyClassManager` uses an explosive state pattern: once you run `.insert()` or `.build()`, that specific instance is closed, forcing you to use the new returned chain instance.
 
 ```javascript
 try {
@@ -142,8 +141,8 @@ try {
   const CoreTest = new TinyClassManager(EntityCore);
   
   // 2. Chain your modules and compile!
-  // If you try to swap the order (.use(Armor).use(Health)), it will throw an explicit dependency error.
-  const FullyArmoredEntity = CoreTest.use(Health).use(Armor).build();
+  // If you try to swap the order (.insert(applyArmor).insert(applyHealth)), it will throw an explicit dependency error.
+  const FullyArmoredEntity = CoreTest.insert(applyHealth).insert(applyArmor).build();
 
   // 3. Create your custom instance!
   const myEntity = new FullyArmoredEntity('Player_1');
@@ -170,5 +169,5 @@ try {
 When you want to build a new set of mechanics for your game or application using this architecture, always remember to follow this loop:
 
 1. **Define your Base State**: Keep it clean and focused on global data configurations.
-2. **Declare Plugins as Pure Objects**: Always structure them with `name`, `dependencies` (an array of strings matching other plugin names), and an `apply` method.
+2. **Declare Plugins as Functions**: Create a function that accepts a `Base` class and returns an extended class. Equip it with `static _tinyDepName` (string) and `static _tinyDeps` (array of strings).
 3. **Use `super` Inheritances**: Inside your plugin classes, always call `super(...)` in constructors and use `super.methodName(...)` if you are overriding an existing skill or function to allow all mixed behaviors to fire smoothly down the pipeline!

package/docs/v1/libs/TinyEvents.md

@@ -111,7 +111,7 @@ Removes a specific listener from an event.
 
 Removes all listeners for one or more events.
 
-#### `offAllTypes(): void`
+#### `offAllTypes(): void` and `removeAllListeners(): void`
 
 Removes **all listeners** for **all events**.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-essentials",
-  "version": "1.26.3",
+  "version": "1.26.4",
   "description": "Collection of small, essential scripts designed to be used across various projects. These simple utilities are crafted for speed, ease of use, and versatility.",
   "bin": {
     "tiny-essentials-fork": "./TinyFork.mjs"