tiny-essentials 1.26.4 → 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,18 +89,24 @@ 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];
   }
 
   /**
    * Internal helper to validate dependencies, check conflicts, and transition state.
-   * @template {new (...args: any[]) => any} R
+   * @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>} A new manager instance.
+   * @returns {TinyClassManager<R, T | oldT>} A new manager instance.
    */
   #validateAndTransition(name, deps, ExtendedClass) {
     // Verifies if the current manager has already been consumed to prevent branching.
@@ -93,17 +124,14 @@ class TinyClassManager {
       }
     }
 
-    /**
-     * @type {TinyClassManager<R>}
-     * The next manager instance wrapping the newly extended class chain.
-     */
-    const newClassManager = new TinyClassManager(ExtendedClass);
-
+    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;
   }
@@ -111,9 +139,9 @@ class TinyClassManager {
   /**
    * 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.
+   * @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) {
@@ -127,7 +155,7 @@ class TinyClassManager {
      * @type {R}
      * The new class generated by the old object-style apply wrapper.
      */
-    const ExtendedClass = plugin.apply(this.#currentClass);
+    const ExtendedClass = plugin.apply(this.#currentClass, this.appliedPluginClasses);
 
     return this.#validateAndTransition(plugin.name, deps, ExtendedClass);
   }
@@ -135,16 +163,16 @@ class TinyClassManager {
   /**
    * 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.
+   * @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);
+    const ExtendedClass = applyFn(this.#currentClass, this.appliedPluginClasses);
 
     /**
      * @type {string}
@@ -185,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.
@@ -52,21 +62,21 @@ declare class TinyClassManager<T extends new (...args: any[]) => any> {
     /**
      * 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.
+     * @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 {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.
+     * @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 new (...args: any[]) => any>(applyFn: (arg0: T) => R): TinyClassManager<R>;
+    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,17 +79,21 @@ 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];
     }
     /**
      * Internal helper to validate dependencies, check conflicts, and transition state.
-     * @template {new (...args: any[]) => any} R
+     * @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>} A new manager instance.
+     * @returns {TinyClassManager<R, T | oldT>} A new manager instance.
      */
     #validateAndTransition(name, deps, ExtendedClass) {
         // Verifies if the current manager has already been consumed to prevent branching.
@@ -78,23 +107,21 @@ class TinyClassManager {
                 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);
+        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 {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.
+     * @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) {
@@ -107,22 +134,22 @@ class TinyClassManager {
          * @type {R}
          * The new class generated by the old object-style apply wrapper.
          */
-        const ExtendedClass = plugin.apply(this.#currentClass);
+        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 {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.
+     * @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);
+        const ExtendedClass = applyFn(this.#currentClass, this.appliedPluginClasses);
         /**
          * @type {string}
          * The plugin name extracted from the static property.
@@ -153,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}

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

@@ -1,13 +1,5 @@
 export default TinyDragDropDetector;
 export type DragAndDropOptions = {
-    /**
-     * - The DOM element where drag listeners will be attached. Defaults to `document.body` if `fullscreen` is true or no target is provided.
-     */
-    target?: HTMLElement | undefined;
-    /**
-     * - If true, listeners are attached to the entire page (`document.body`). If false, the `target` must be specified.
-     */
-    fullscreen?: boolean | undefined;
     /**
      * - CSS class applied to the target element while files are being dragged over it.
      */
@@ -27,8 +19,6 @@ export type DragAndDropOptions = {
 };
 /**
  * @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.
@@ -41,20 +31,21 @@ export type DragAndDropOptions = {
  * 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
  */
-declare class TinyDragDropDetector {
+declare class TinyDragDropDetector<HTMLTarget extends HTMLElement> {
     /**
      * 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?: DragAndDropOptions);
+    constructor(target: HTMLTarget, options: DragAndDropOptions);
     /**
      * Handles the `dragenter` event.
      * Adds the hover CSS class and triggers the `onEnter` callback if provided.
@@ -89,19 +80,14 @@ declare class TinyDragDropDetector {
     private _handleDrop;
     /**
      * Returns the current target DOM element where the listeners are attached.
-     * @returns {HTMLElement}
+     * @returns {HTMLTarget}
      */
-    getTarget(): HTMLElement;
+    getTarget(): HTMLTarget;
     /**
      * Returns the CSS class applied during drag hover.
      * @returns {string}
      */
     getHoverClass(): string;
-    /**
-     * Indicates whether the detector is operating in fullscreen mode.
-     * @returns {boolean}
-     */
-    isFullScreen(): boolean;
     /**
      * Returns whether a drag operation is currently active over the target.
      * @returns {boolean}