tiny-essentials 1.26.3 → 1.27.0

package/dist/v1/libs/TinyClassManager.cjs

@@ -1,19 +1,25 @@
 'use strict';
 
+/** @typedef {new (...args: any[]) => any} NewTinyClass */
+
 /**
- * @template {new (...args: any[]) => any} TBase
- * @template {new (...args: any[]) => any} TExtended
+ * @template {NewTinyClass} TBase
+ * @template {NewTinyClass} TExtended
+ * @template {NewTinyClass[]} AppliedPluginClasses
  * @typedef {Object} PluginDefinition
  * @property {string} name - The unique identifier for the plugin.
  * @property {string[]} [dependencies] - Array of plugin names required before applying this one.
- * @property {function(TBase): TExtended} apply - Function that receives the base class and returns the extended class.
+ * @property {function(TBase, AppliedPluginClasses): TExtended} apply - Function that receives the base class and returns the extended class.
  */
 
 /**
  * Manages the composition of a base class with multiple optional plugins (Mixins).
- * @template {new (...args: any[]) => any} T
+ * @template {NewTinyClass} T
+ * @template {T|NewTinyClass} oldT
  */
 class TinyClassManager {
+  /** @typedef {[...oldT[], T]} AppliedPluginClasses */
+
   /**
    * @type {Set<string>}
    * Tracks the names of successfully applied plugins to prevent duplication and check dependencies.
@@ -25,15 +31,33 @@ class TinyClassManager {
    * @returns {string[]} Array of applied plugin names.
    */
   get appliedPlugins() {
+    if (this.#used) throw new Error(`[TinyClassManager] Cannot get a consumed manager instance.`);
     return [...this.#appliedPlugins];
   }
 
+  /**
+   * @type {AppliedPluginClasses}
+   * Tracks the classes of successfully applied plugins to prevent duplication and check dependencies.
+   */
+  // @ts-ignore
+  #appliedPluginClasses = [];
+
+  /**
+   * Gets the list of plugin classes currently applied to this instance.
+   * @returns {AppliedPluginClasses} Array of applied plugin classes.
+   */
+  get appliedPluginClasses() {
+    if (this.#used) throw new Error(`[TinyClassManager] Cannot get a consumed manager instance.`);
+    return [...this.#appliedPluginClasses];
+  }
+
   /**
    * Gets the total size of the current class chain hierarchy.
    * @returns {number} The count of applied plugins plus the core base.
    */
   get size() {
-    return this.#appliedPlugins.size + 1;
+    if (this.#used) throw new Error(`[TinyClassManager] Cannot get a consumed manager instance.`);
+    return this.#appliedPluginClasses.length;
   }
 
   /**
@@ -46,6 +70,7 @@ class TinyClassManager {
    * Holds the current state of the class chain.
    */
   get currentClass() {
+    if (this.#used) throw new Error(`[TinyClassManager] Cannot get a consumed manager instance.`);
     return this.#currentClass;
   }
 
@@ -64,46 +89,120 @@ class TinyClassManager {
   /**
    * Initializes the manager with a core class.
    * @param {T} coreClass - The foundational class to be extended.
+   * @param {oldT[]} [oldClasses=[]]
    */
-  constructor(coreClass) {
+  constructor(
+    coreClass,
+    // @ts-ignore
+    oldClasses = [],
+  ) {
     this.#currentClass = coreClass;
+    this.#appliedPluginClasses = [...oldClasses, coreClass];
   }
 
   /**
-   * Applies a plugin to the class chain if all conditions are met.
-   * @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.
+   * Internal helper to validate dependencies, check conflicts, and transition state.
+   * @template {NewTinyClass} 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, T | oldT>} 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);
+    const newClassManager = new TinyClassManager(ExtendedClass, this.#appliedPluginClasses);
+    this.#appliedPlugins.forEach((appliedName) => newClassManager.#appliedPlugins.add(appliedName));
+    newClassManager.#appliedPlugins.add(name);
 
     this.#used = true;
     this.#appliedPlugins.clear();
+    // @ts-ignore
+    this.#appliedPluginClasses = [];
+
     return newClassManager;
   }
 
+  /**
+   * Applies a plugin to the class chain using a definition object.
+   * @deprecated Use {@link insert} instead.
+   * @template {NewTinyClass} R
+   * @param {PluginDefinition<T, R, AppliedPluginClasses>} plugin - The plugin module to be integrated.
+   * @returns {TinyClassManager<R, T | oldT>} 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, this.appliedPluginClasses);
+
+    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 {NewTinyClass} R
+   * @param {function(T, AppliedPluginClasses): R} applyFn - Function that receives the base class and returns the extended class.
+   * @returns {TinyClassManager<R, T | oldT>} 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, this.appliedPluginClasses);
+
+    /**
+     * @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.
@@ -114,6 +213,8 @@ class TinyClassManager {
       throw new Error(`[TinyClassManager] Cannot build from an already finalized manager.`);
     this.#used = true;
     this.#appliedPlugins.clear();
+    // @ts-ignore
+    this.#appliedPluginClasses = [];
     return this.#currentClass;
   }
 }

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

@@ -1,5 +1,6 @@
 export default TinyClassManager;
-export type PluginDefinition<TBase extends new (...args: any[]) => any, TExtended extends new (...args: any[]) => any> = {
+export type NewTinyClass = new (...args: any[]) => any;
+export type PluginDefinition<TBase extends NewTinyClass, TExtended extends NewTinyClass, AppliedPluginClasses extends NewTinyClass[]> = {
     /**
      * - The unique identifier for the plugin.
      */
@@ -11,31 +12,40 @@ export type PluginDefinition<TBase extends new (...args: any[]) => any, TExtende
     /**
      * - Function that receives the base class and returns the extended class.
      */
-    apply: (arg0: TBase) => TExtended;
+    apply: (arg0: TBase, arg1: AppliedPluginClasses) => TExtended;
 };
+/** @typedef {new (...args: any[]) => any} NewTinyClass */
 /**
- * @template {new (...args: any[]) => any} TBase
- * @template {new (...args: any[]) => any} TExtended
+ * @template {NewTinyClass} TBase
+ * @template {NewTinyClass} TExtended
+ * @template {NewTinyClass[]} AppliedPluginClasses
  * @typedef {Object} PluginDefinition
  * @property {string} name - The unique identifier for the plugin.
  * @property {string[]} [dependencies] - Array of plugin names required before applying this one.
- * @property {function(TBase): TExtended} apply - Function that receives the base class and returns the extended class.
+ * @property {function(TBase, AppliedPluginClasses): TExtended} apply - Function that receives the base class and returns the extended class.
  */
 /**
  * Manages the composition of a base class with multiple optional plugins (Mixins).
- * @template {new (...args: any[]) => any} T
+ * @template {NewTinyClass} T
+ * @template {T|NewTinyClass} oldT
  */
-declare class TinyClassManager<T extends new (...args: any[]) => any> {
+declare class TinyClassManager<T extends NewTinyClass, oldT extends T | NewTinyClass> {
     /**
      * Initializes the manager with a core class.
      * @param {T} coreClass - The foundational class to be extended.
+     * @param {oldT[]} [oldClasses=[]]
      */
-    constructor(coreClass: T);
+    constructor(coreClass: T, oldClasses?: oldT[]);
     /**
      * Gets the list of plugins currently applied to this instance.
      * @returns {string[]} Array of applied plugin names.
      */
     get appliedPlugins(): string[];
+    /**
+     * Gets the list of plugin classes currently applied to this instance.
+     * @returns {AppliedPluginClasses} Array of applied plugin classes.
+     */
+    get appliedPluginClasses(): [...oldT[], T];
     /**
      * Gets the total size of the current class chain hierarchy.
      * @returns {number} The count of applied plugins plus the core base.
@@ -50,13 +60,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.
-     * @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.
+     * Applies a plugin to the class chain using a definition object.
+     * @deprecated Use {@link insert} instead.
+     * @template {NewTinyClass} R
+     * @param {PluginDefinition<T, R, AppliedPluginClasses>} plugin - The plugin module to be integrated.
+     * @returns {TinyClassManager<R, T | oldT>} 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>;
+    use<R extends NewTinyClass>(plugin: PluginDefinition<T, R, [...oldT[], T]>): TinyClassManager<R, T | oldT>;
+    /**
+     * Inserts a plugin directly by passing its apply function.
+     * It reads `_tinyDepName` and `_tinyDeps` statically from the returned class.
+     * @template {NewTinyClass} R
+     * @param {function(T, AppliedPluginClasses): R} applyFn - Function that receives the base class and returns the extended class.
+     * @returns {TinyClassManager<R, T | oldT>} 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 NewTinyClass>(applyFn: (arg0: T, arg1: [...oldT[], T]) => R): TinyClassManager<R, T | oldT>;
     /**
      * 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

@@ -1,16 +1,20 @@
+/** @typedef {new (...args: any[]) => any} NewTinyClass */
 /**
- * @template {new (...args: any[]) => any} TBase
- * @template {new (...args: any[]) => any} TExtended
+ * @template {NewTinyClass} TBase
+ * @template {NewTinyClass} TExtended
+ * @template {NewTinyClass[]} AppliedPluginClasses
  * @typedef {Object} PluginDefinition
  * @property {string} name - The unique identifier for the plugin.
  * @property {string[]} [dependencies] - Array of plugin names required before applying this one.
- * @property {function(TBase): TExtended} apply - Function that receives the base class and returns the extended class.
+ * @property {function(TBase, AppliedPluginClasses): TExtended} apply - Function that receives the base class and returns the extended class.
  */
 /**
  * Manages the composition of a base class with multiple optional plugins (Mixins).
- * @template {new (...args: any[]) => any} T
+ * @template {NewTinyClass} T
+ * @template {T|NewTinyClass} oldT
  */
 class TinyClassManager {
+    /** @typedef {[...oldT[], T]} AppliedPluginClasses */
     /**
      * @type {Set<string>}
      * Tracks the names of successfully applied plugins to prevent duplication and check dependencies.
@@ -21,14 +25,33 @@ class TinyClassManager {
      * @returns {string[]} Array of applied plugin names.
      */
     get appliedPlugins() {
+        if (this.#used)
+            throw new Error(`[TinyClassManager] Cannot get a consumed manager instance.`);
         return [...this.#appliedPlugins];
     }
+    /**
+     * @type {AppliedPluginClasses}
+     * Tracks the classes of successfully applied plugins to prevent duplication and check dependencies.
+     */
+    // @ts-ignore
+    #appliedPluginClasses = [];
+    /**
+     * Gets the list of plugin classes currently applied to this instance.
+     * @returns {AppliedPluginClasses} Array of applied plugin classes.
+     */
+    get appliedPluginClasses() {
+        if (this.#used)
+            throw new Error(`[TinyClassManager] Cannot get a consumed manager instance.`);
+        return [...this.#appliedPluginClasses];
+    }
     /**
      * Gets the total size of the current class chain hierarchy.
      * @returns {number} The count of applied plugins plus the core base.
      */
     get size() {
-        return this.#appliedPlugins.size + 1;
+        if (this.#used)
+            throw new Error(`[TinyClassManager] Cannot get a consumed manager instance.`);
+        return this.#appliedPluginClasses.length;
     }
     /**
      * @type {T}
@@ -39,6 +62,8 @@ class TinyClassManager {
      * Holds the current state of the class chain.
      */
     get currentClass() {
+        if (this.#used)
+            throw new Error(`[TinyClassManager] Cannot get a consumed manager instance.`);
         return this.#currentClass;
     }
     /**
@@ -54,39 +79,97 @@ class TinyClassManager {
     /**
      * Initializes the manager with a core class.
      * @param {T} coreClass - The foundational class to be extended.
+     * @param {oldT[]} [oldClasses=[]]
      */
-    constructor(coreClass) {
+    constructor(coreClass, 
+    // @ts-ignore
+    oldClasses = []) {
         this.#currentClass = coreClass;
+        this.#appliedPluginClasses = [...oldClasses, coreClass];
     }
     /**
-     * Applies a plugin to the class chain if all conditions are met.
-     * @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.
+     * Internal helper to validate dependencies, check conflicts, and transition state.
+     * @template {NewTinyClass} 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, T | oldT>} 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.`);
+                throw new Error(`[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);
+        const newClassManager = new TinyClassManager(ExtendedClass, this.#appliedPluginClasses);
+        this.#appliedPlugins.forEach((appliedName) => newClassManager.#appliedPlugins.add(appliedName));
+        newClassManager.#appliedPlugins.add(name);
         this.#used = true;
         this.#appliedPlugins.clear();
+        // @ts-ignore
+        this.#appliedPluginClasses = [];
         return newClassManager;
     }
+    /**
+     * Applies a plugin to the class chain using a definition object.
+     * @deprecated Use {@link insert} instead.
+     * @template {NewTinyClass} R
+     * @param {PluginDefinition<T, R, AppliedPluginClasses>} plugin - The plugin module to be integrated.
+     * @returns {TinyClassManager<R, T | oldT>} 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, this.appliedPluginClasses);
+        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 {NewTinyClass} R
+     * @param {function(T, AppliedPluginClasses): R} applyFn - Function that receives the base class and returns the extended class.
+     * @returns {TinyClassManager<R, T | oldT>} 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, this.appliedPluginClasses);
+        /**
+         * @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.
@@ -97,6 +180,8 @@ class TinyClassManager {
             throw new Error(`[TinyClassManager] Cannot build from an already finalized manager.`);
         this.#used = true;
         this.#appliedPlugins.clear();
+        // @ts-ignore
+        this.#appliedPluginClasses = [];
         return this.#currentClass;
     }
 }

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

@@ -80,22 +80,22 @@ export type ColorTypes = "hex" | "hexa" | "rgb" | "rgba" | "hsl" | "hsla" | "hwb
  * @template {string} TinyColorValidatorT
  */
 declare class TinyColorValidator<TinyColorValidatorT extends string> {
-    static "__#private@#HEX_REGEX": RegExp;
-    static "__#private@#HEXA_REGEX": RegExp;
-    static "__#private@#ALPHA": string;
-    static "__#private@#NUM_0_255": string;
-    static "__#private@#NUM_0_360": string;
-    static "__#private@#NUM_0_100": string;
-    static "__#private@#RGB_REGEX": RegExp;
-    static "__#private@#RGBA_REGEX": RegExp;
-    static "__#private@#HSL_REGEX": RegExp;
-    static "__#private@#HSLA_REGEX": RegExp;
-    static "__#private@#HWB_REGEX": RegExp;
-    static "__#private@#LAB_AB": string;
-    static "__#private@#LAB_REGEX": RegExp;
-    static "__#private@#LCH_REGEX": RegExp;
-    static "__#private@#HTML_COLOR_NAMES": Set<string>;
-    static "__#private@#SPECIAL_COLOR_NAMES": Set<string>;
+    static #HEX_REGEX: RegExp;
+    static #HEXA_REGEX: RegExp;
+    static #ALPHA: string;
+    static #NUM_0_255: string;
+    static #NUM_0_360: string;
+    static #NUM_0_100: string;
+    static #RGB_REGEX: RegExp;
+    static #RGBA_REGEX: RegExp;
+    static #HSL_REGEX: RegExp;
+    static #HSLA_REGEX: RegExp;
+    static #HWB_REGEX: RegExp;
+    static #LAB_AB: string;
+    static #LAB_REGEX: RegExp;
+    static #LCH_REGEX: RegExp;
+    static #HTML_COLOR_NAMES: Set<string>;
+    static #SPECIAL_COLOR_NAMES: Set<string>;
     /**
      * Returns all HTML color names as an array.
      * @returns {string[]}

package/dist/v1/libs/TinyDragDropDetector.cjs

@@ -2,8 +2,6 @@
 
 /**
  * @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.
@@ -17,14 +15,12 @@
  * It handles the drag lifecycle (enter, over, leave, drop) and provides hooks for developers to handle file uploads or UI changes.
  *
  * @class
+ * @template {HTMLElement} HTMLTarget
  */
 class TinyDragDropDetector {
-  /** @type {HTMLElement} */
+  /** @type {HTMLTarget} */
   #target;
 
-  /** @type {boolean} */
-  #fullscreen;
-
   /** @type {string} */
   #hoverClass;
 
@@ -46,31 +42,19 @@ class TinyDragDropDetector {
   /**
    * Creates a new instance of TinyDragDropDetector to handle drag-and-drop file detection.
    *
-   * @param {DragAndDropOptions} [options={}] - Configuration options for the detector.
+   * @param {HTMLTarget} target - The DOM element where drag listeners will be attached.
+   * @param {DragAndDropOptions} options - Configuration options for the detector.
    * @throws {TypeError} If `target` is not an HTMLElement.
-   * @throws {TypeError} If `fullscreen` is not a boolean.
    * @throws {TypeError} If `hoverClass` is not a string.
    * @throws {TypeError} If `onDrop` is defined but not a function.
    * @throws {TypeError} If `onEnter` is defined but not a function.
    * @throws {TypeError} If `onLeave` is defined but not a function.
    */
-  constructor(options = {}) {
-    const {
-      target,
-      fullscreen = true,
-      hoverClass = 'dnd-hover',
-      onDrop,
-      onEnter,
-      onLeave,
-    } = options;
-
-    // Validate fullscreen
-    if (typeof fullscreen !== 'boolean')
-      throw new TypeError('The "fullscreen" option must be a boolean.');
+  constructor(target, options) {
+    const { hoverClass = 'dnd-hover', onDrop, onEnter, onLeave } = options;
 
     // Validate target
-    const resolvedTarget = fullscreen ? document.body : target || document.body;
-    if (!(resolvedTarget instanceof HTMLElement))
+    if (!(target instanceof HTMLElement))
       throw new TypeError('The "target" option must be an instance of HTMLElement.');
 
     // Validate hoverClass
@@ -90,8 +74,7 @@ class TinyDragDropDetector {
       throw new TypeError('The "onLeave" option must be a function.');
 
     // Store properties
-    this.#target = resolvedTarget;
-    this.#fullscreen = fullscreen;
+    this.#target = target;
     this.#hoverClass = hoverClass;
 
     this.#onDropCallback = onDrop || (() => {});
@@ -112,7 +95,7 @@ class TinyDragDropDetector {
 
   /**
    * Returns the current target DOM element where the listeners are attached.
-   * @returns {HTMLElement}
+   * @returns {HTMLTarget}
    */
   getTarget() {
     return this.#target;
@@ -126,14 +109,6 @@ class TinyDragDropDetector {
     return this.#hoverClass;
   }
 
-  /**
-   * Indicates whether the detector is operating in fullscreen mode.
-   * @returns {boolean}
-   */
-  isFullScreen() {
-    return this.#fullscreen;
-  }
-
   /**
    * Returns whether a drag operation is currently active over the target.
    * @returns {boolean}