tiny-essentials 1.26.3 → 1.27.0

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}`);

package/docs/v1/README.md

@@ -20,6 +20,7 @@ Here, you can navigate through different sections of the project. Below are the
 - 🖼️ **[Html](./basics/html.md)** — Utilities for handling DOM element interactions like collision detection and basic element manipulation.
 - 📺 **[FullScreen](./basics/fullScreen.md)** — A complete fullscreen API manager with detection, event handling, and cross-browser compatibility.
 - 🧱 **[Collision](./basics/collision.md)** — Full-featured rectangle collision detection system with directional analysis, depth calculation, and center offset metrics.
+- 🎵 **[MediaContent](./basics/mediaContent.md)** — A comprehensive media processing module for downloading audio, extracting rich ID3 metadata, and managing image blobs for album art.
 
 ### 2. **`libs/`**
 - 🗂️ **[TinyPromiseQueue](./libs/TinyPromiseQueue.md)** — A class that allows sequential execution of asynchronous tasks, supporting task delays, cancellation, and queue management.
@@ -62,7 +63,12 @@ Here, you can navigate through different sections of the project. Below are the
 * 🕒 **[TinyAnalogClock](./libs/TinyAnalogClock.md)** — A lightweight analog clock engine for managing time-based rotations, supporting custom offsets, smooth transitions, and easy binding to CSS variables rendering.
 * 🔍 **[TinyArrayComparator](./libs/TinyArrayComparator.md)** — A lightweight, highly optimized JavaScript utility class designed to compare two arrays and efficiently detect which items were **added** or **deleted**.
 * 🧠 **[TinyMamdaniInferenceSystem](./libs/TinyMamdaniInferenceSystem.md)** — A implementation of a Mamdani Inference System, allowing you to model logic using trapezoidal membership functions.
+* ⏯️ **[TinyMediaPlayer](./libs/TinyMediaPlayer.md)** — A universal media player architecture utilizing an adapter pattern to orchestrate multiple platform APIs, featuring robust playlist management, playback controls, and weighted random selection.
+
+### 2.1. **`libs/TinyClassManager`**
+
 * ⚙️ **[TinyClassManager](./libs/TinyClassManager.md)** — A lightweight, immutable manager designed to linearly compose a base class with multiple modular plugins, featuring automatic dependency verification and duplicate conflict protection.
+* 🛠️ **[TinyPluginInliner](./libs/TinyClassManager/TinyPluginInliner.md)** — A powerful build-time utility that inlines plugin code into a single bundle, automatically rewriting import paths and hoisting dependencies for seamless deployment.
 
 ### 3. **`fileManager/`**
 * 📁 **[Main](./fileManager/main.md)** — A Node.js file/directory utility module with support for JSON, backups, renaming, size analysis, and more.

package/docs/v1/basics/mediaContent.md

@@ -0,0 +1,131 @@
+# 🎵 Media Content Module
+
+Welcome to the documentation for the media content module! This module is the heart of the media processing pipeline, responsible for downloading audio, extracting rich metadata (ID3 tags), managing memory for image blobs, and preparing finalized `MediaContent` objects for the radio system. 🚀
+
+---
+
+## 📦 Data Structures & Types
+
+These definitions ensure type safety and provide a clear blueprint for how media information is structured throughout the application.
+
+### 🎼 Core Metadata Types
+
+| Type | Description |
+| :--- | :--- |
+| `MediaContent` | **The Final Object.** A combination of `MediaContentBase` and `MediaContentMetadata`. This is what the system uses for playback. |
+| `MediaContentBase` | The essential properties: `id`, `title`, `artist`, `duration`, `url`, and `weight`. |
+| `MediaContentMetadata` | Rich metadata modeled after `music-metadata`. Includes `album`, `genre`, `year`, `track` info, etc. |
+| `MediaNumber` | A structure for indexing: `{ no: number \| null, of: number \| null }`. |
+| `UnknownArtistGetter` | A type that can be a `string` or a function returning a `string`. |
+
+### 🖼️ Image & Picture Types
+
+| Type | Description |
+| :--- | :--- |
+| `IPicture` | Represents an image attachment (like album art). |
+| `IPictureTemplate<T>` | A generic template for pictures, where `T` is the data type (`Uint8Array` or `string`). |
+
+### 🚦 Progress & Error Types
+
+| Type | Description |
+| :--- | :--- |
+| `LoadingMediaProgress` | Tracks the current state: `status` ('loading' or 'success'), `stage`, and the `url`. |
+| `LoadingProgressStage` | Stages: `INITIALIZING` ➡️ `DOWNLOADING` ➡️ `METADATA_LOADED` ➡️ `EXTRACTING_ID3` ➡️ `COMPLETE`. |
+| `LoadingErrorStage` | Error stages: `INITIALIZING`, `DOWNLOADING`, `METADATA`, `ID3`, or `UNKNOWN`. |
+
+---
+
+## ❌ Custom Errors
+
+### `MediaLoadingError`
+Used to provide specific context when something goes wrong during the media preparation lifecycle.
+
+*   **Properties:**
+    *   `message`: Human-readable error description.
+    *   `url`: The URL that caused the failure.
+    *   `stage`: The `LoadingErrorStage` where the error occurred.
+
+---
+
+## 🛠️ Utility Functions
+
+### Factory & Validation
+
+| Function | Description |
+| :--- | :--- |
+| `getMediaContentBase` | Returns a fresh, empty `MediaContentBase` object. |
+| `getMediaContentMetadata` | Returns a fresh, empty `MediaContentMetadata` object. |
+| `valMediaContentMetadata` | Performs strict validation on a full `MediaContentMetadata` object. |
+| `valMediaContentMetadataPartial` | Performs validation on a partial metadata object (useful for patches/updates). |
+
+### Data & Memory Management
+
+| Function | Description |
+| :--- | :--- |
+| `generateSimpleHash` | Generates a deterministic 8-character ID from a string using SHA-1. |
+| `convertToBlobUrl` | Converts `Uint8Array` or Base64 strings into high-performance Blob URLs. It also tracks usage to prevent memory leaks. |
+| `blobUrlToBase64` | Converts a `blob:` URL back into a Base64 Data URL. Useful for exporting data. |
+| `revokeContentUrls` | Safely cleans up memory by revoking Blob URLs associated with a `MediaContent` object. **Call this when media is no longer needed!** 🧹 |
+
+---
+
+## 🚀 Main Operations
+
+### `extractMediaId3Tags`
+Downloads an audio file and uses a provided parser to extract its internal metadata.
+
+*   **Parameters:**
+    *   `url` (string): The full URL of the audio file.
+    *   `parseFile` (Function): A callback that accepts a `Blob` and returns a promise with metadata.
+*   **Returns:** `Promise<MediaContentMetadata>`
+*   **Throws:** `TypeError` for invalid arguments or `Error` for network/parsing failures.
+
+---
+
+### `parseMediaMetadata`
+**The Primary Factory Method.** This is the main entry point for turning a URL or an Audio element into a fully prepared `MediaContent` object. It handles the heavy lifting: downloading, metadata extraction, fallback logic, and progress reporting.
+
+#### 📝 Parameters
+
+| Parameter | Type | Description |
+| :--- | :--- | :--- |
+| `source` | `string \| HTMLMediaElement` | The audio source (URL or Audio object). |
+| `defaultMetadata` | `Partial<MediaContent>` | Default data for the metadata. |
+| `metadata` | `Partial<MediaContent>` | Manual overrides for the metadata (highest priority). |
+| `parseFile` | `ParseMediaContentMetadata` | The library function used to parse the file. |
+| `callbacks` | `Object` | Contains `onProgress` and `onError` listeners. |
+| `unknownArtist` | `UnknownArtistGetter` | Logic to determine the artist if none is found. |
+
+#### 💡 Usage Examples
+
+**1. Using a simple URL with manual overrides:**
+```javascript
+import { parseMediaMetadata } from './mediaContent.mjs';
+import { parseBlob } from 'music-metadata';
+
+// Note: We pass empty objects for default/manual if we want to jump straight to the parser
+const track = await parseMediaMetadata(
+  '/assets/song.mp3', 
+  {}, 
+  { title: 'Manual Override' }, 
+  parseBlob
+);
+
+console.log(track.title); // "Manual Override"
+```
+
+**2. Using an existing Audio object with progress tracking:**
+```javascript
+const audio = new Audio('/assets/song.mp3');
+
+const track = await parseMediaMetadata(
+  audio,
+  {},
+  {},
+  parseBlob,
+  {
+    onProgress: (p) => console.log(`[${p.stage}] ${p.status}`),
+    onError: (e) => console.error(`Error at ${e.stage}: ${e.error.message}`)
+  }
+);
+```

package/docs/v1/libs/TinyClassManager/TinyPluginInliner.md

@@ -0,0 +1,107 @@
+# 🛠️ TinyPluginInliner
+
+`TinyPluginInliner` is a powerful **build-time utility** designed specifically to complement the `TinyClassManager`. 
+
+When using `TinyClassManager`, you compose classes using a mixin pattern via the `.insert()` method. While this is incredibly flexible for development, it creates a challenge for deployment: you end up with many small, interconnected files and complex import paths. 
+
+**`TinyPluginInliner` solves this by "inlining" your plugins directly into a single, self-contained bundle.** It automates the process of fetching plugin code, rewriting their internal import paths, and hoisting dependencies to the top of your final file. 🚀
+
+---
+
+## ✨ Key Features
+
+* **📦 Automatic Inlining:** It scans your entry file for `.insert(PluginName)` calls and replaces them with the actual source code of the plugin.
+* **🔗 Smart Path Rewriting:** It automatically corrects `import` statements inside your plugins so they point to the correct relative locations in your `dist` folder.
+* **📚 JSDoc Support:** It doesn't just fix code; it also rewrites `import()` calls and `@typedef` paths inside JSDoc comments, ensuring your IDE (like VS Code) keeps providing perfect autocomplete in the bundled version.
+* **🌐 NPM Integration:** It can reach into your `node_modules`, grab an NPM package used by a plugin, and inline it into your bundle, even fixing that package's internal relative paths!
+* **🔄 Root Remapping:** Through `rootReplacement`, you can tell the inliner to automatically swap directory names (e.g., changing all `src/` imports to `dist/` imports).
+* **🔝 Dependency Hoisting:** It collects all necessary imports and type definitions from all plugins and moves them to the very top of the generated file for a clean, valid structure.
+
+---
+
+## ⚙️ Configuration
+
+When creating an instance of `TinyPluginInliner`, you provide an `InlinerConfig` object:
+
+| Property | Type | Description |
+| :--- | :--- | :--- |
+| `entryPoint` | `string` | The absolute or relative path to your main file (where you call `.insert()`). |
+| `outDir` | `string` | The directory where the final bundle will be saved. |
+| `outFileName` | `string` | The name of the generated bundle file (e.g., `bundle.mjs`). |
+| `rootReplacement` | `Object` | *(Optional)* An object `{ from: string, to: string }` to remap project roots. |
+
+---
+
+## 🚀 How to Use
+
+### 1. Develop your Plugins
+Your plugins must follow the `TinyClassManager` requirement of having static properties for identification.
+
+```javascript
+// src/plugins/LoggerPlugin.mjs
+export class LoggerPlugin {
+  static _tinyDepName = 'Logger';
+  static _tinyDeps = [];
+
+  constructor(Base) {
+    super();
+    this.log = (msg) => console.log(`[LOG]: ${msg}`);
+  }
+}
+```
+
+### 2. Create your Entry Point
+This is the file that uses the `TinyClassManager` to compose your final class.
+
+```javascript
+// src/main.mjs
+import TinyClassManager from './libs/TinyClassManager.mjs';
+import { LoggerPlugin } from './plugins/LoggerPlugin.mjs';
+
+class BaseUser {}
+
+// The Inliner will look for this specific pattern!
+const User = new TinyClassManager(BaseUser)
+  .insert(LoggerPlugin) 
+  .build();
+
+export default User;
+```
+
+### 3. Run the Inliner
+Create a build script (e.g., `build.mjs`) to trigger the process.
+
+```javascript
+import TinyPluginInliner from './libs/TinyClassManager/TinyPluginInliner.mjs';
+
+const builder = new TinyPluginInliner({
+  entryPoint: 'src/main.mjs',
+  outDir: 'dist',
+  outFileName: 'app.bundle.mjs',
+  // This ensures that if a plugin imports from 'src/utils', 
+  // it will be rewritten to 'dist/utils' in the bundle.
+  rootReplacement: {
+    from: 'src',
+    to: 'dist',
+  },
+});
+
+builder.build();
+```
+
+---
+
+## 🔄 Before vs. After
+
+### 📝 Before (Development)
+Your project is a web of files:
+* `src/main.mjs` $\rightarrow$ imports `LoggerPlugin`
+* `src/plugins/LoggerPlugin.mjs` $\rightarrow$ imports `src/utils/helper.mjs`
+
+### 📦 After (Production Bundle)
+The `dist/app.bundle.mjs` is a single, massive, but perfectly valid file:
+1. **Top:** All imports from `main.mjs`, `LoggerPlugin.mjs`, and `helper.mjs` are hoisted here.
+2. **Middle:** All `@typedef` definitions are gathered here.
+3. **Bottom:** The logic of `main.mjs` runs, but the `.insert(LoggerPlugin)` call has been replaced by the actual code of the `LoggerPlugin` class, which now correctly references the hoisted helper functions.
+
+**Everything is ready to be shipped!** 🚢💨

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/TinyDragDropDetector.md

@@ -21,7 +21,6 @@ A lightweight JavaScript utility for detecting drag-and-drop file operations on
 import TinyDragDropDetector from './TinyDragDropDetector.js';
 
 const dnd = new TinyDragDropDetector({
-  fullscreen: false,
   target: document.getElementById('drop-area'),
   hoverClass: 'hover-effect',
   onDrop: (files, event) => {
@@ -50,19 +49,19 @@ A drag-and-drop detector instance.
 ### Constructor
 
 ```javascript
-new TinyDragDropDetector(options)
+new TinyDragDropDetector(target, options)
 ```
 
 #### Parameters:
 
-| Name      | Type                                        | Default | Description           |
-| --------- | ------------------------------------------- | ------- | --------------------- |
-| `options` | [`DragAndDropOptions`](#draganddropoptions) | `{}`    | Configuration object. |
+| Name      | Type                                        | Description           |
+| --------- | ------------------------------------------- | ------------------------------------------------------- |
+| `target`  | `HTMLElement`                               | The DOM element where drag listeners will be attached.  |
+| `options` | [`DragAndDropOptions`](#draganddropoptions) | Configuration object.                                   |
 
 #### Throws:
 
 * `TypeError` if `target` is not an `HTMLElement`.
-* `TypeError` if `fullscreen` is not a boolean.
 * `TypeError` if `hoverClass` is not a string.
 * `TypeError` if `onDrop` is not a function.
 * `TypeError` if `onEnter` is defined but not a function.
@@ -76,7 +75,6 @@ new TinyDragDropDetector(options)
 | ----------------- | ------------- | ------------------------------------------------------------------------ |
 | `getTarget()`     | `HTMLElement` | Returns the DOM element where listeners are attached.                    |
 | `getHoverClass()` | `string`      | Returns the CSS class applied during drag hover.                         |
-| `isFullScreen()`  | `boolean`     | Indicates whether the detector is in fullscreen mode (`document.body`).  |
 | `isDragging()`    | `boolean`     | Returns whether a drag operation is currently active over the target.    |
 | `bound()`         | `boolean`     | Returns whether the event listeners are currently bound to the target.   |
 | `destroy()`       | `void`        | Destroys the detector, unbinding all events and cleaning up CSS classes. |
@@ -98,8 +96,6 @@ new TinyDragDropDetector(options)
 ```javascript
 /**
  * @typedef {Object} DragAndDropOptions
- * @property {HTMLElement} [target=document.body] - The DOM element where drag listeners will be attached. Defaults to `document.body` if `fullscreen` is true or no target is provided.
- * @property {boolean} [fullscreen=true] - If true, listeners are attached to the entire page (`document.body`). If false, the `target` must be specified.
  * @property {string} [hoverClass="dnd-hover"] - CSS class applied to the target element while files are being dragged over it.
  * @property {(files: FileList, event: DragEvent) => void} onDrop - Callback function executed when files are dropped onto the target.
  * @property {(event: DragEvent) => void} [onEnter] - Optional callback triggered when dragging enters the target area.

package/docs/v1/libs/TinyElementObserver.md

@@ -22,14 +22,13 @@ type ElementDetectorsFn = (
 ## 🔹 Constructor
 
 ```ts
-new TinyElementObserver({
-  el?: Element,
+new TinyElementObserver(el, {
   initDetectors?: Array<[string, ElementDetectorsFn]>,
   initCfg?: MutationObserverInit
 })
 ```
 
-* **`el`** *(optional)* → Initial element to observe 🏷️
+* **`el`** → Initial element to observe 🏷️
 * **`initDetectors`** *(optional)* → Array of detectors to register on creation 🎛️
 * **`initCfg`** *(optional)* → Initial `MutationObserverInit` configuration ⚙️
 
@@ -39,7 +38,6 @@ new TinyElementObserver({
 
 | Property    | Type                                  | Description                                               |
 | ----------- | ------------------------------------- | --------------------------------------------------------- |
-| `el`        | `Element \| undefined`                | The DOM element being observed. Can only be set once. 🏗️ |
 | `settings`  | `MutationObserverInit`                | Observer configuration object. 🔧                         |
 | `observer`  | `MutationObserver \| null`            | Internal observer instance.                               |
 | `detectors` | `Array<[string, ElementDetectorsFn]>` | List of registered detectors.                             |
@@ -85,8 +83,7 @@ const logDetector = (mutation, index, mutations) => {
 };
 
 // Create instance
-const observer = new TinyElementObserver({
-  el: document.querySelector('#target'),
+const observer = new TinyElementObserver(document.querySelector('#target'), {
   initDetectors: [['logger', logDetector]],
   initCfg: { childList: true, subtree: true }
 });

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**.