tiny-essentials 1.20.0 → 1.20.2

package/dist/v1/TinyDomReadyManager.js

@@ -1,213 +0,0 @@
-/******/ (() => { // webpackBootstrap
-/******/ 	"use strict";
-/******/ 	// The require scope
-/******/ 	var __webpack_require__ = {};
-/******/ 	
-/************************************************************************/
-/******/ 	/* webpack/runtime/define property getters */
-/******/ 	(() => {
-/******/ 		// define getter functions for harmony exports
-/******/ 		__webpack_require__.d = (exports, definition) => {
-/******/ 			for(var key in definition) {
-/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-/******/ 				}
-/******/ 			}
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
-/******/ 	(() => {
-/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
-/******/ 	})();
-/******/ 	
-/************************************************************************/
-var __webpack_exports__ = {};
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  TinyDomReadyManager: () => (/* reexport */ libs_TinyDomReadyManager)
-});
-
-;// ./src/v1/libs/TinyDomReadyManager.mjs
-/**
- * A basic function that performs a task when the system is ready.
- * Used for handlers in the readiness queue.
- *
- * @typedef {() => void} Fn
- */
-
-/**
- * A function that determines whether a specific handler should be executed.
- * Should return `true` to allow execution, or `false` to skip the handler.
- *
- * @typedef {() => boolean} FnFilter
- */
-
-/**
- * @typedef {Object} Handler
- * @property {Fn} fn - Function to execute when ready.
- * @property {boolean} once - Whether to execute only once.
- * @property {number} priority - Execution order (higher priority runs first).
- * @property {FnFilter|null} filter - Optional filter function to determine execution.
- * @property {boolean} domOnly - Whether to run as soon as DOM is ready (before full readiness).
- */
-
-class TinyDomReadyManager {
-  /** @type {Handler[]} */
-  #handlers = [];
-
-  /** @type {boolean} */
-  #isDomReady = false;
-
-  /** @type {boolean} */
-  #isFullyReady = false;
-
-  /** @type {Promise<any>[]} */
-  #promises = [];
-
-  /**
-   * Checks if the DOM is ready and if all Promises have been resolved.
-   */
-  #checkAllReady() {
-    if (this.#isDomReady) {
-      Promise.all(this.#promises)
-        .then(() => {
-          this.#isFullyReady = true;
-          this.#runHandlers(false); // run non-domOnly
-        })
-        .catch((err) => {
-          console.error('[TinyDomReadyManager] Promise rejected:', err);
-        });
-    }
-  }
-
-  /**
-   * Executes handlers by filtering them by `domOnly` flag and sorting by priority.
-   * @param {boolean} domOnlyOnly - Whether to run only `domOnly` handlers.
-   */
-  #runHandlers(domOnlyOnly) {
-    this.#handlers
-      .filter((h) => h.domOnly === domOnlyOnly)
-      .sort((a, b) => b.priority - a.priority)
-      .forEach((handler) => this.#invokeHandler(handler));
-
-    this.#handlers = this.#handlers.filter((h) => !(h.once && (domOnlyOnly ? h.domOnly : true)));
-  }
-
-  /**
-   * Executes a handler if its filter passes.
-   * @param {Handler} handler
-   */
-  #invokeHandler(handler) {
-    if (typeof handler.filter === 'function') {
-      try {
-        if (!handler.filter()) return;
-      } catch (err) {
-        console.warn('[TinyDomReadyManager] Filter error:', err);
-        return;
-      }
-    }
-
-    try {
-      handler.fn();
-    } catch (err) {
-      console.error('[TinyDomReadyManager] Handler error:', err);
-    }
-  }
-
-  /**
-   * Marks the system as DOM-ready and runs DOM-only handlers.
-   * @private
-   */
-  _markDomReady() {
-    this.#isDomReady = true;
-    this.#runHandlers(true); // Run domOnly
-    this.#checkAllReady(); // Then check for full readiness
-  }
-
-  /**
-   * Initializes the manager using `DOMContentLoaded`.
-   */
-  init() {
-    if (this.#isDomReady) throw new Error('[TinyDomReadyManager] init() has already been called.');
-
-    if (document.readyState === 'interactive' || document.readyState === 'complete') {
-      this._markDomReady();
-    } else {
-      document.addEventListener('DOMContentLoaded', () => this._markDomReady());
-    }
-  }
-
-  /**
-   * Adds a Promise to delay full readiness.
-   * @param {Promise<any>} promise
-   * @throws {TypeError}
-   */
-  addPromise(promise) {
-    if (!(promise instanceof Promise))
-      throw new TypeError('[TinyDomReadyManager] promise must be a valid Promise.');
-
-    if (this.#isFullyReady) return;
-    this.#promises.push(promise);
-    if (this.#isDomReady) this.#checkAllReady();
-  }
-
-  /**
-   * Registers a handler to run either after DOM is ready or after full readiness.
-   *
-   * @param {Fn} fn - Function to execute.
-   * @param {Object} [options]
-   * @param {boolean} [options.once=true] - Execute only once.
-   * @param {number} [options.priority=0] - Higher priority runs first.
-   * @param {FnFilter|null} [options.filter=null] - Optional filter function.
-   * @param {boolean} [options.domOnly=false] - If true, executes after DOM ready only.
-   * @throws {TypeError} If fn is not a function.
-   */
-  onReady(fn, { once = true, priority = 0, filter = null, domOnly = false } = {}) {
-    if (typeof fn !== 'function')
-      throw new TypeError('[TinyDomReadyManager] fn must be a function.');
-
-    const handler = { fn, once, priority, filter, domOnly };
-
-    if (domOnly && this.#isDomReady) {
-      this.#invokeHandler(handler);
-      if (!once) this.#handlers.push(handler);
-      return;
-    }
-
-    if (!domOnly && this.#isFullyReady) {
-      this.#invokeHandler(handler);
-    } else {
-      this.#handlers.push(handler);
-    }
-  }
-
-  /**
-   * Returns whether the system is fully ready (DOM + Promises).
-   * @returns {boolean}
-   */
-  isReady() {
-    return this.#isFullyReady;
-  }
-
-  /**
-   * Returns whether the DOM is ready (DOMContentLoaded has fired).
-   * Does not wait for promises.
-   * @returns {boolean}
-   */
-  isDomReady() {
-    return this.#isDomReady;
-  }
-}
-
-/* harmony default export */ const libs_TinyDomReadyManager = (TinyDomReadyManager);
-
-;// ./src/v1/build/TinyDomReadyManager.mjs
-
-
-
-
-window.TinyDomReadyManager = __webpack_exports__.TinyDomReadyManager;
-/******/ })()
-;

package/dist/v1/TinyDragDropDetector.js

@@ -1,307 +0,0 @@
-/******/ (() => { // webpackBootstrap
-/******/ 	"use strict";
-/******/ 	// The require scope
-/******/ 	var __webpack_require__ = {};
-/******/ 	
-/************************************************************************/
-/******/ 	/* webpack/runtime/define property getters */
-/******/ 	(() => {
-/******/ 		// define getter functions for harmony exports
-/******/ 		__webpack_require__.d = (exports, definition) => {
-/******/ 			for(var key in definition) {
-/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-/******/ 				}
-/******/ 			}
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
-/******/ 	(() => {
-/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
-/******/ 	})();
-/******/ 	
-/************************************************************************/
-var __webpack_exports__ = {};
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  TinyDragDropDetector: () => (/* reexport */ libs_TinyDragDropDetector)
-});
-
-;// ./src/v1/libs/TinyDragDropDetector.mjs
-/**
- * @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.
- * @property {(event: DragEvent) => void} [onLeave] - Optional callback triggered when dragging leaves the target area.
- */
-
-/**
- * TinyDragDropDetector
- *
- * A lightweight utility to detect drag-and-drop file operations on a specific DOM element or the entire page.
- * It handles the drag lifecycle (enter, over, leave, drop) and provides hooks for developers to handle file uploads or UI changes.
- *
- * @class
- */
-class TinyDragDropDetector {
-  /** @type {HTMLElement} */
-  #target;
-
-  /** @type {boolean} */
-  #fullscreen;
-
-  /** @type {string} */
-  #hoverClass;
-
-  /** @type {(files: FileList, event: DragEvent) => void} */
-  #onDropCallback;
-
-  /** @type {(event: DragEvent) => void} */
-  #onEnterCallback;
-
-  /** @type {(event: DragEvent) => void} */
-  #onLeaveCallback;
-
-  /** @type {boolean} */
-  #isDragging;
-
-  /** @type {boolean} */
-  #bound;
-
-  /**
-   * Creates a new instance of TinyDragDropDetector to handle drag-and-drop file detection.
-   *
-   * @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.');
-
-    // Validate target
-    const resolvedTarget = fullscreen ? document.body : target || document.body;
-    if (!(resolvedTarget instanceof HTMLElement))
-      throw new TypeError('The "target" option must be an instance of HTMLElement.');
-
-    // Validate hoverClass
-    if (typeof hoverClass !== 'string')
-      throw new TypeError('The "hoverClass" option must be a string.');
-
-    // Validate onDrop
-    if (typeof onDrop !== 'function')
-      throw new TypeError('The "onDrop" option must be a function.');
-
-    // Validate onEnter
-    if (typeof onEnter !== 'function')
-      throw new TypeError('The "onEnter" option must be a function.');
-
-    // Validate onLeave
-    if (typeof onLeave !== 'function')
-      throw new TypeError('The "onLeave" option must be a function.');
-
-    // Store properties
-    this.#target = resolvedTarget;
-    this.#fullscreen = fullscreen;
-    this.#hoverClass = hoverClass;
-
-    this.#onDropCallback = onDrop || (() => {});
-    this.#onEnterCallback = onEnter;
-    this.#onLeaveCallback = onLeave;
-
-    this.#isDragging = false;
-    this.#bound = false;
-
-    // Bind event handlers
-    this._handleDragEnter = this._handleDragEnter.bind(this);
-    this._handleDragOver = this._handleDragOver.bind(this);
-    this._handleDragLeave = this._handleDragLeave.bind(this);
-    this._handleDrop = this._handleDrop.bind(this);
-
-    this.#bindEvents();
-  }
-
-  /**
-   * Returns the current target DOM element where the listeners are attached.
-   * @returns {HTMLElement}
-   */
-  getTarget() {
-    return this.#target;
-  }
-
-  /**
-   * Returns the CSS class applied during drag hover.
-   * @returns {string}
-   */
-  getHoverClass() {
-    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}
-   */
-  isDragging() {
-    return this.#isDragging;
-  }
-
-  /**
-   * Returns whether the event listeners are currently bound to the target.
-   * @returns {boolean}
-   */
-  bound() {
-    return this.#bound;
-  }
-
-  /**
-   * Binds the drag-and-drop event listeners to the target element.
-   * Automatically called on instantiation.
-   * @returns {void}
-   */
-  #bindEvents() {
-    if (this.#bound) return;
-    const target = this.getTarget();
-    target.addEventListener('dragenter', this._handleDragEnter);
-    target.addEventListener('dragover', this._handleDragOver);
-    target.addEventListener('dragleave', this._handleDragLeave);
-    target.addEventListener('drop', this._handleDrop);
-    this.#bound = true;
-  }
-
-  /**
-   * Removes all previously attached drag-and-drop event listeners from the target.
-   * @returns {void}
-   */
-  #unbindEvents() {
-    if (!this.#bound) return;
-    const target = this.getTarget();
-    target.removeEventListener('dragenter', this._handleDragEnter);
-    target.removeEventListener('dragover', this._handleDragOver);
-    target.removeEventListener('dragleave', this._handleDragLeave);
-    target.removeEventListener('drop', this._handleDrop);
-    this.#bound = false;
-  }
-
-  /**
-   * Handles the `dragenter` event.
-   * Adds the hover CSS class and triggers the `onEnter` callback if provided.
-   * @private
-   * @param {DragEvent} event - The dragenter event.
-   * @returns {void}
-   */
-  _handleDragEnter(event) {
-    event.preventDefault();
-    if (!this.#isDragging) {
-      const target = this.getTarget();
-      this.#isDragging = true;
-      target.classList.add(this.#hoverClass);
-      this.#onEnterCallback(event);
-    }
-  }
-
-  /**
-   * Handles the `dragover` event.
-   * Prevents default to allow drop and sets the drop effect.
-   * @private
-   * @param {DragEvent} event - The dragover event.
-   * @returns {void}
-   */
-  _handleDragOver(event) {
-    event.preventDefault(); // Required to allow drop
-    if (!event.dataTransfer) {
-      console.warn('[TinyDragDropDetector] [handleDragOver] DragOver event missing dataTransfer.');
-      return;
-    }
-    event.dataTransfer.dropEffect = 'copy';
-  }
-
-  /**
-   * Handles the `dragleave` event.
-   * Removes the hover class and triggers the `onLeave` callback if provided.
-   * @private
-   * @param {DragEvent} event - The dragleave event.
-   * @returns {void}
-   */
-  _handleDragLeave(event) {
-    event.preventDefault();
-    const target = this.getTarget();
-    // Check if you've completely left the area
-    // @ts-ignore
-    if (event.relatedTarget === null || !target.contains(event.relatedTarget)) {
-      this.#isDragging = false;
-      target.classList.remove(this.#hoverClass);
-      this.#onLeaveCallback(event);
-    }
-  }
-
-  /**
-   * Handles the `drop` event.
-   * Removes the hover class, resets dragging state, and triggers the `onDrop` callback.
-   * @private
-   * @param {DragEvent} event - The drop event.
-   * @returns {void}
-   */
-  _handleDrop(event) {
-    event.preventDefault();
-    if (!event.dataTransfer) {
-      console.warn('[TinyDragDropDetector] [handleDrop] DragOver event missing dataTransfer.');
-      return;
-    }
-    const target = this.getTarget();
-    this.#isDragging = false;
-    target.classList.remove(this.#hoverClass);
-    const files = event.dataTransfer.files;
-    if (files.length > 0) {
-      this.#onDropCallback(files, event);
-    }
-  }
-
-  /**
-   * Destroys the detector instance, unbinding all event listeners and cleaning up.
-   * Should be called when the detector is no longer needed to avoid memory leaks.
-   * @returns {void}
-   */
-  destroy() {
-    this.#unbindEvents();
-    const target = this.getTarget();
-    target.classList.remove(this.#hoverClass);
-  }
-}
-
-/* harmony default export */ const libs_TinyDragDropDetector = (TinyDragDropDetector);
-
-;// ./src/v1/build/TinyDragDropDetector.mjs
-
-
-
-
-window.TinyDragDropDetector = __webpack_exports__.TinyDragDropDetector;
-/******/ })()
-;