tiny-essentials 1.28.1 → 1.28.3

package/dist/v1/basics/collision.d.mts

@@ -1,97 +1,16 @@
-/**
- * Calculates the offset between the center of rect2 and the center of rect1.
- *
- * The values will be 0 when rect1 is perfectly centered over rect2.
- *
- * @param {ObjRect} rect1 - The bounding rectangle of the reference element.
- * @param {ObjRect} rect2 - The bounding rectangle of the element being compared.
- * @returns {{
- *   x: number,
- *   y: number
- * }} An object with the X and Y offset in pixels from rect1's center to rect2's center.
- */
-export function getElsRelativeCenterOffset(rect1: ObjRect, rect2: ObjRect): {
-    x: number;
-    y: number;
-};
-/**
- * Detects the direction of the dominant collision between two elements
- * and calculates how deep the overlap is in both x and y axes.
- *
- * @param {ObjRect} rect1 - The bounding rectangle of the first element.
- * @param {ObjRect} rect2 - The bounding rectangle of the second element.
- * @returns {{
- *   inDir: Dirs | null;
- *   dirX: Dirs | null;
- *   dirY: Dirs | null;
- *   depthX: number;
- *   depthY: number;
- * }} An object containing the collision direction and how deep the overlap is.
- */
-export function getElsCollDirDepth(rect1: ObjRect, rect2: ObjRect): {
-    inDir: Dirs | null;
-    dirX: Dirs | null;
-    dirY: Dirs | null;
-    depthX: number;
-    depthY: number;
-};
-/**
- * Detects the collision direction and depth between two DOMRects.
- *
- * @param {ObjRect} rect1 - The bounding rectangle of the first element.
- * @param {ObjRect} rect2 - The bounding rectangle of the second element.
- * @returns {{ depth: CollData; dirs: CollDirs; isNeg: NegCollDirs; }} Collision info or null if no collision is detected.
- */
-export function getElsCollDetails(rect1: ObjRect, rect2: ObjRect): {
-    depth: CollData;
-    dirs: CollDirs;
-    isNeg: NegCollDirs;
-};
-export function areElsCollTop(rect1: ObjRect, rect2: ObjRect): boolean;
-export function areElsCollBottom(rect1: ObjRect, rect2: ObjRect): boolean;
-export function areElsCollLeft(rect1: ObjRect, rect2: ObjRect): boolean;
-export function areElsCollRight(rect1: ObjRect, rect2: ObjRect): boolean;
-export function areElsCollPerfTop(rect1: ObjRect, rect2: ObjRect): boolean;
-export function areElsCollPerfBottom(rect1: ObjRect, rect2: ObjRect): boolean;
-export function areElsCollPerfLeft(rect1: ObjRect, rect2: ObjRect): boolean;
-export function areElsCollPerfRight(rect1: ObjRect, rect2: ObjRect): boolean;
-export function areElsColliding(rect1: ObjRect, rect2: ObjRect): boolean;
-export function areElsPerfColliding(rect1: ObjRect, rect2: ObjRect): boolean;
-export function getElsColliding(rect1: ObjRect, rect2: ObjRect): string | null;
-export function getElsPerfColliding(rect1: ObjRect, rect2: ObjRect): "top" | "bottom" | "left" | "right" | null;
-export function getElsCollOverlap(rect1: ObjRect, rect2: ObjRect): {
-    overlapLeft: number;
-    overlapRight: number;
-    overlapTop: number;
-    overlapBottom: number;
-};
-export function getElsCollOverlapPos({ overlapLeft, overlapRight, overlapTop, overlapBottom, }?: {
-    overlapLeft?: number | undefined;
-    overlapRight?: number | undefined;
-    overlapTop?: number | undefined;
-    overlapBottom?: number | undefined;
-}): {
-    dirX: Dirs;
-    dirY: Dirs;
-};
-export function getRectCenter(rect: ObjRect): {
-    x: number;
-    y: number;
-};
 /**
  * A direction relative to a rectangle.
  *
  * Represents one of the four cardinal directions from the perspective of the element.
+ *
+ * @typedef {'top' | 'bottom' | 'left' | 'right'} Dirs
  */
-export type Dirs = "top" | "bottom" | "left" | "right";
-/**
- * Represents all directional aspects of a collision.
- */
+export type Dirs = 'top' | 'bottom' | 'left' | 'right';
 export type CollDirs = {
     /**
      * - The dominant direction of entry. `'center'` if all sides are equally overlapped. `null` if no collision.
      */
-    in: Dirs | "center" | null;
+    in: Dirs | 'center' | null;
     /**
      * - The horizontal direction (`'left'` or `'right'`) the collision is biased toward, or `null`.
      */
@@ -101,9 +20,6 @@ export type CollDirs = {
      */
     y: Dirs | null;
 };
-/**
- * Indicates if a collision is in the negative direction (rect2 is outside rect1).
- */
 export type NegCollDirs = {
     /**
      * - Horizontal direction of negative overlap, if any.
@@ -114,11 +30,6 @@ export type NegCollDirs = {
      */
     y: Dirs | null;
 };
-/**
- * Collision depth values from each side of rect2 inside rect1.
- *
- * Positive values indicate penetration; negative values indicate gaps.
- */
 export type CollData = {
     /**
      * - Depth from rect2's top into rect1.
@@ -137,11 +48,6 @@ export type CollData = {
      */
     right: number;
 };
-/**
- * X and Y offset representing center difference between two rectangles.
- *
- * Useful to measure how far one element's center is from another.
- */
 export type CollCenter = {
     /**
      * - Horizontal distance in pixels from rect1's center to rect2's center.
@@ -152,12 +58,6 @@ export type CollCenter = {
      */
     y: number;
 };
-/**
- * Represents a rectangular area in absolute pixel values.
- *
- * Similar to `DOMRect`, this object describes the dimensions and position of a box
- * in the 2D plane, typically representing an element's bounding box.
- */
 export type ObjRect = {
     /**
      * - The total height of the rectangle in pixels.
@@ -184,4 +84,245 @@ export type ObjRect = {
      */
     right: number;
 };
+/**
+ * Represents all directional aspects of a collision.
+ *
+ * @typedef {Object} CollDirs
+ * @property {Dirs | 'center' | null} in - The dominant direction of entry. `'center'` if all sides are equally overlapped. `null` if no collision.
+ * @property {Dirs | null} x - The horizontal direction (`'left'` or `'right'`) the collision is biased toward, or `null`.
+ * @property {Dirs | null} y - The vertical direction (`'top'` or `'bottom'`) the collision is biased toward, or `null`.
+ */
+/**
+ * Indicates if a collision is in the negative direction (rect2 is outside rect1).
+ *
+ * @typedef {Object} NegCollDirs
+ * @property {Dirs | null} x - Horizontal direction of negative overlap, if any.
+ * @property {Dirs | null} y - Vertical direction of negative overlap, if any.
+ */
+/**
+ * Collision depth values from each side of rect2 inside rect1.
+ *
+ * Positive values indicate penetration; negative values indicate gaps.
+ *
+ * @typedef {Object} CollData
+ * @property {number} top - Depth from rect2's top into rect1.
+ * @property {number} bottom - Depth from rect2's bottom into rect1.
+ * @property {number} left - Depth from rect2's left into rect1.
+ * @property {number} right - Depth from rect2's right into rect1.
+ */
+/**
+ * X and Y offset representing center difference between two rectangles.
+ *
+ * Useful to measure how far one element's center is from another.
+ *
+ * @typedef {Object} CollCenter
+ * @property {number} x - Horizontal distance in pixels from rect1's center to rect2's center.
+ * @property {number} y - Vertical distance in pixels from rect1's center to rect2's center.
+ */
+/**
+ * Represents a rectangular area in absolute pixel values.
+ *
+ * Similar to `DOMRect`, this object describes the dimensions and position of a box
+ * in the 2D plane, typically representing an element's bounding box.
+ *
+ * @typedef {Object} ObjRect
+ * @property {number} height - The total height of the rectangle in pixels.
+ * @property {number} width - The total width of the rectangle in pixels.
+ * @property {number} top - The Y-coordinate of the top edge of the rectangle.
+ * @property {number} bottom - The Y-coordinate of the bottom edge of the rectangle.
+ * @property {number} left - The X-coordinate of the left edge of the rectangle.
+ * @property {number} right - The X-coordinate of the right edge of the rectangle.
+ */
+/**
+ * Checks if rect1 is completely above rect2 (no vertical overlap).
+ *
+ * @param {ObjRect} rect1 - The bounding rectangle of the first element.
+ * @param {ObjRect} rect2 - The bounding rectangle of the second element.
+ * @returns {boolean} True if rect1 is entirely above rect2.
+ */
+export declare const areElsCollTop: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Checks if rect1 is completely below rect2 (no vertical overlap).
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {boolean} True if rect1 is entirely below rect2.
+ */
+export declare const areElsCollBottom: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Checks if rect1 is completely to the left of rect2 (no horizontal overlap).
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {boolean} True if rect1 is entirely to the left of rect2.
+ */
+export declare const areElsCollLeft: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Checks if rect1 is completely to the right of rect2 (no horizontal overlap).
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {boolean} True if rect1 is entirely to the right of rect2.
+ */
+export declare const areElsCollRight: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Checks if rect1 is perfectly above rect2 (no vertical touch or overlap).
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {boolean} True if rect1 is fully above or touching rect2's top.
+ */
+export declare const areElsCollPerfTop: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Checks if rect1 is perfectly below rect2 (no vertical touch or overlap).
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {boolean} True if rect1 is fully below or touching rect2's bottom.
+ */
+export declare const areElsCollPerfBottom: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Checks if rect1 is perfectly to the left of rect2 (no horizontal touch or overlap).
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {boolean} True if rect1 is fully left or touching rect2's left.
+ */
+export declare const areElsCollPerfLeft: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Checks if rect1 is perfectly to the right of rect2 (no horizontal touch or overlap).
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {boolean} True if rect1 is fully right or touching rect2's right.
+ */
+export declare const areElsCollPerfRight: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Returns true if rect1 and rect2 are colliding (partially or fully overlapping).
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {boolean} True if there's any collision between rect1 and rect2.
+ */
+export declare const areElsColliding: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Returns true if rect1 and rect2 are colliding or perfectly touching.
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {boolean} True if there's any contact or overlap.
+ */
+export declare const areElsPerfColliding: (rect1: ObjRect, rect2: ObjRect) => boolean;
+/**
+ * Attempts to determine the direction rect1 entered rect2 based on loose overlap rules.
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {string|null} 'top' | 'bottom' | 'left' | 'right' | null
+ */
+export declare const getElsColliding: (rect1: ObjRect, rect2: ObjRect) => string | null;
+/**
+ * Attempts to determine the direction rect1 touched or entered rect2 using perfect mode.
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {'top' | 'bottom' | 'left' | 'right' | null}
+ */
+export declare const getElsPerfColliding: (rect1: ObjRect, rect2: ObjRect) => 'top' | 'bottom' | 'left' | 'right' | null;
+/**
+ * Calculates overlap values between rect1 and rect2 in all directions.
+ *
+ * @param {ObjRect} rect1
+ * @param {ObjRect} rect2
+ * @returns {{
+ *   overlapLeft: number,
+ *   overlapRight: number,
+ *   overlapTop: number,
+ *   overlapBottom: number
+ * }} Distance of overlap from each direction (can be negative).
+ */
+export declare const getElsCollOverlap: (rect1: ObjRect, rect2: ObjRect) => {
+    overlapLeft: number;
+    overlapRight: number;
+    overlapTop: number;
+    overlapBottom: number;
+};
+/**
+ * Determines directional collision based on overlap depth.
+ *
+ * @param {Object} [settings={}]
+ * @param {number} [settings.overlapLeft]
+ * @param {number} [settings.overlapRight]
+ * @param {number} [settings.overlapTop]
+ * @param {number} [settings.overlapBottom]
+ * @returns {{ dirX: Dirs, dirY: Dirs }} Direction of strongest X/Y overlap.
+ */
+export declare const getElsCollOverlapPos: ({ overlapLeft, overlapRight, overlapTop, overlapBottom, }?: {
+    overlapLeft?: number;
+    overlapRight?: number;
+    overlapTop?: number;
+    overlapBottom?: number;
+}) => {
+    dirX: Dirs;
+    dirY: Dirs;
+};
+/**
+ * Calculates the center point (X and Y) of a given Rect.
+ *
+ * @param {ObjRect} rect - The bounding rectangle of the element.
+ * @returns {{ x: number, y: number }} An object with the `x` and `y` coordinates of the center.
+ */
+export declare const getRectCenter: (rect: ObjRect) => {
+    x: number;
+    y: number;
+};
+/**
+ * Calculates the offset between the center of rect2 and the center of rect1.
+ *
+ * The values will be 0 when rect1 is perfectly centered over rect2.
+ *
+ * @param {ObjRect} rect1 - The bounding rectangle of the reference element.
+ * @param {ObjRect} rect2 - The bounding rectangle of the element being compared.
+ * @returns {{
+ *   x: number,
+ *   y: number
+ * }} An object with the X and Y offset in pixels from rect1's center to rect2's center.
+ */
+export declare function getElsRelativeCenterOffset(rect1: ObjRect, rect2: ObjRect): {
+    x: number;
+    y: number;
+};
+/**
+ * Detects the direction of the dominant collision between two elements
+ * and calculates how deep the overlap is in both x and y axes.
+ *
+ * @param {ObjRect} rect1 - The bounding rectangle of the first element.
+ * @param {ObjRect} rect2 - The bounding rectangle of the second element.
+ * @returns {{
+ *   inDir: Dirs | null;
+ *   dirX: Dirs | null;
+ *   dirY: Dirs | null;
+ *   depthX: number;
+ *   depthY: number;
+ * }} An object containing the collision direction and how deep the overlap is.
+ */
+export declare function getElsCollDirDepth(rect1: ObjRect, rect2: ObjRect): {
+    inDir: Dirs | null;
+    dirX: Dirs | null;
+    dirY: Dirs | null;
+    depthX: number;
+    depthY: number;
+};
+/**
+ * Detects the collision direction and depth between two DOMRects.
+ *
+ * @param {ObjRect} rect1 - The bounding rectangle of the first element.
+ * @param {ObjRect} rect2 - The bounding rectangle of the second element.
+ * @returns {{ depth: CollData; dirs: CollDirs; isNeg: NegCollDirs; }} Collision info or null if no collision is detected.
+ */
+export declare function getElsCollDetails(rect1: ObjRect, rect2: ObjRect): {
+    depth: CollData;
+    dirs: CollDirs;
+    isNeg: NegCollDirs;
+};
 //# sourceMappingURL=collision.d.mts.map

package/dist/v1/basics/deprecated/html.d.mts

@@ -1,3 +1,33 @@
+export type FetchTemplateOptions = {
+    /**
+     * - HTTP method to use (GET, POST, etc.).
+     */
+    method?: string;
+    /**
+     * - Request body (only for methods like POST, PUT).
+     */
+    body?: any;
+    /**
+     * - Timeout in milliseconds (ignored if signal is provided).
+     */
+    timeout?: number;
+    /**
+     * - Number of retry attempts (ignored if signal is provided).
+     */
+    retries?: number;
+    /**
+     * - Additional headers.
+     */
+    headers?: Headers | Record<string, any>;
+    /**
+     * - External AbortSignal; disables timeout and retries.
+     */
+    signal?: AbortSignal | null;
+    /**
+     * - Track the load progress.
+     */
+    onProgress?: import('../html.mjs').FetchOnProgressResult;
+};
 /**
  * Loads and parses a JSON from a remote URL using Fetch API.
  *
@@ -7,7 +37,7 @@
  * @throws {Error} Throws if fetch fails, times out, or returns invalid JSON.
  * @deprecated
  */
-export function fetchJson(url: string, options?: FetchTemplateOptions): Promise<any[] | Record<string | number | symbol, unknown>>;
+export declare function fetchJson(url: string, options?: FetchTemplateOptions): Promise<any[] | Record<string | number | symbol, unknown>>;
 /**
  * Loads a remote file as a Blob using Fetch API.
  *
@@ -18,7 +48,7 @@ export function fetchJson(url: string, options?: FetchTemplateOptions): Promise<
  * @throws {Error} Throws if fetch fails, response is not ok, or MIME type is not allowed.
  * @deprecated
  */
-export function fetchBlob(url: string, allowedMimeTypes?: string[], options?: FetchTemplateOptions): Promise<Blob>;
+export declare function fetchBlob(url: string, allowedMimeTypes?: string[], options?: FetchTemplateOptions): Promise<Blob>;
 /**
  * Loads a remote file as a text using Fetch API.
  *
@@ -29,35 +59,5 @@ export function fetchBlob(url: string, allowedMimeTypes?: string[], options?: Fe
  * @throws {Error} Throws if fetch fails, response is not ok, or MIME type is not allowed.
  * @deprecated
  */
-export function fetchText(url: string, allowedMimeTypes?: string[], options?: FetchTemplateOptions): Promise<string>;
-export type FetchTemplateOptions = {
-    /**
-     * - HTTP method to use (GET, POST, etc.).
-     */
-    method?: string | undefined;
-    /**
-     * - Request body (only for methods like POST, PUT).
-     */
-    body?: any;
-    /**
-     * - Timeout in milliseconds (ignored if signal is provided).
-     */
-    timeout?: number | undefined;
-    /**
-     * - Number of retry attempts (ignored if signal is provided).
-     */
-    retries?: number | undefined;
-    /**
-     * - Additional headers.
-     */
-    headers?: Headers | Record<string, any> | undefined;
-    /**
-     * - External AbortSignal; disables timeout and retries.
-     */
-    signal?: AbortSignal | null | undefined;
-    /**
-     * - Track the load progress.
-     */
-    onProgress?: import("../html.mjs").FetchOnProgressResult | undefined;
-};
+export declare function fetchText(url: string, allowedMimeTypes?: string[], options?: FetchTemplateOptions): Promise<string>;
 //# sourceMappingURL=html.d.mts.map

package/dist/v1/basics/extendObjType/Buffer.d.mts

@@ -1,4 +1,4 @@
+import { Buffer } from 'buffer';
 declare const _default: (string | ((val: any) => val is Buffer))[][];
 export default _default;
-import { Buffer } from 'buffer';
 //# sourceMappingURL=Buffer.d.mts.map

package/dist/v1/basics/fullScreen.d.mts

@@ -1,8 +1,48 @@
-export function documentIsFullScreen(): boolean;
-export function isScreenFilled(): boolean;
-export function isFullScreenMode(): boolean;
-export function requestFullScreen(ops?: FullscreenOptions): Promise<void>;
-export function exitFullScreen(): Promise<void>;
-export function onFullScreenChange(listener: EventListenerOrEventListenerObject, ops?: boolean | AddEventListenerOptions): void;
-export function offFullScreenChange(listener: EventListenerOrEventListenerObject, ops?: boolean | AddEventListenerOptions): void;
+/**
+ * Checks if the document is currently in fullscreen mode.
+ *
+ * @returns {boolean}
+ */
+export declare const documentIsFullScreen: () => boolean;
+/**
+ * Checks if the window occupies the entire screen dimensions.
+ *
+ * @returns {boolean}
+ */
+export declare const isScreenFilled: () => boolean;
+/**
+ * Checks if fullscreen mode is active either via document API or by matching screen dimensions.
+ *
+ * @returns {boolean}
+ */
+export declare const isFullScreenMode: () => boolean;
+/**
+ * Requests fullscreen mode for the document.
+ *
+ * @param {FullscreenOptions} [ops]
+ * @returns {Promise<void>}
+ */
+export declare const requestFullScreen: (ops?: FullscreenOptions) => Promise<void>;
+/**
+ * Exits fullscreen mode.
+ *
+ * @returns {Promise<void>}
+ */
+export declare const exitFullScreen: () => Promise<void>;
+/**
+ * Attaches a listener to fullscreen change events.
+ *
+ * @param {EventListenerOrEventListenerObject} listener
+ * @param {boolean|AddEventListenerOptions} [ops]
+ * @returns {void}
+ */
+export declare const onFullScreenChange: (listener: EventListenerOrEventListenerObject, ops?: boolean | AddEventListenerOptions) => void;
+/**
+ * Removes a listener from fullscreen change events.
+ *
+ * @param {EventListenerOrEventListenerObject} listener
+ * @param {boolean|AddEventListenerOptions} [ops]
+ * @returns {void}
+ */
+export declare const offFullScreenChange: (listener: EventListenerOrEventListenerObject, ops?: boolean | AddEventListenerOptions) => void;
 //# sourceMappingURL=fullScreen.d.mts.map