@arex95/vue-core 1.0.0

package/dist/vue-core.esm.js

@@ -0,0 +1,1993 @@
+import axios from 'axios';
+import '@tanstack/vue-query';
+import { computed } from 'vue';
+import { useTimeoutFn } from '@vueuse/core';
+
+/**
+ * AxiosService class encapsulates the Axios configuration and logic.
+ * It manages request and response interceptors and provides methods for making HTTP requests.
+ */
+class AxiosService {
+    instance;
+    cancelTokenSource;
+    activeRequests = 0; // Track active requests
+    /**
+     * Initializes the AxiosService instance by creating an Axios instance with default configuration
+     * and setting up request and response interceptors.
+     */
+    constructor(url) {
+        this.cancelTokenSource = axios.CancelToken.source();
+        this.instance = axios.create({
+            baseURL: url ?? '',
+            timeout: 300000,
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            withCredentials: false,
+        });
+        this.initializeInterceptors();
+    }
+    /**
+     * Initializes request and response interceptors for the Axios instance.
+     */
+    initializeInterceptors() {
+        this.instance.interceptors.request.use((config) => {
+            const token = typeof window !== 'undefined' ? localStorage.getItem('authToken') : null;
+            if (token && config.headers) {
+                config.headers.Authorization = `Bearer ${token}`;
+            }
+            config.cancelToken = this.cancelTokenSource.token;
+            this.activeRequests++;
+            return config;
+        }, (error) => {
+            // handleError(error);
+            console.error('Request error:', error.message);
+            this.activeRequests++;
+            return Promise.reject(error);
+        });
+        this.instance.interceptors.response.use((response) => {
+            this.activeRequests--;
+            return response;
+        }, (error) => {
+            if (axios.isCancel(error)) {
+                console.warn('Request canceled:', error.message);
+            }
+            else if (axios.isAxiosError(error)) {
+                // handleError(error);
+                console.error('Response error:', error.response?.status, error.message);
+                if (error.response?.status === 401) {
+                    this.handleUnauthorized();
+                }
+            }
+            else {
+                console.error('Unexpected error:', error);
+            }
+            this.activeRequests--;
+            return Promise.reject(error);
+        });
+    }
+    /**
+     * Returns the number of active requests.
+     */
+    getActiveRequests() {
+        return this.activeRequests;
+    }
+    /**
+     * Handles unauthorized access errors (401).
+     */
+    handleUnauthorized() {
+        console.warn('Unauthorized access - redirecting to login.');
+    }
+    /**
+     * Returns the Axios instance with the configured settings and interceptors.
+     * @returns {AxiosInstance} The configured Axios instance.
+     */
+    getAxiosInstance() {
+        return this.instance;
+    }
+    /**
+     * Cancels all ongoing requests.
+     */
+    cancelAllRequests() {
+        this.cancelTokenSource.cancel('Operation canceled by the user.');
+        this.cancelTokenSource = axios.CancelToken.source();
+    }
+    /**
+     * Sets a new header for the Axios instance.
+     * @param {string} key - The header key.
+     * @param {string} value - The header value.
+     */
+    setHeader(key, value) {
+        this.instance.defaults.headers.common[key] = value;
+    }
+    /**
+     * Removes a header from the Axios instance.
+     * @param {string} key - The header key to remove.
+     */
+    removeHeader(key) {
+        delete this.instance.defaults.headers.common[key];
+    }
+}
+
+/**
+ * Custom composable for sorting products based on a selected criterion.
+ * @param {Array} items - The array of products to sort.
+ * @param {Array} criteriaList - The list of available sorting criteria.
+ * @param {Number} selectedCriteria - The currently selected sorting criterion.
+ * @returns {ComputedRef<Array>} - The sorted array of products.
+ */
+function useSorter(items, criteriaList, selectedCriteria) {
+    return computed(() => {
+        const criteria = criteriaList.find(item => item.value === Number(selectedCriteria));
+        if (!criteria)
+            return items;
+        return [...items].sort((a, b) => {
+            const aValue = a[criteria.field];
+            const bValue = b[criteria.field];
+            if (criteria.type === 'number') {
+                const numA = typeof aValue === 'number' ? aValue : parseFloat(aValue) || 0;
+                const numB = typeof bValue === 'number' ? bValue : parseFloat(bValue) || 0;
+                return criteria.order === 'asc' ? numA - numB : numB - numA;
+            }
+            else if (criteria.type === 'date') {
+                const dateA = new Date(aValue).getTime();
+                const dateB = new Date(bValue).getTime();
+                return criteria.order === 'asc' ? dateA - dateB : dateB - dateA;
+            }
+            else if (criteria.type === 'boolean') {
+                const boolA = !!aValue;
+                const boolB = !!bValue;
+                return criteria.order === 'asc' ? (boolA === boolB ? 0 : boolA ? 1 : -1) : (boolA === boolB ? 0 : boolA ? -1 : 1);
+            }
+            else {
+                // Fallback for string sorting
+                const strA = (aValue || '').toString().toLowerCase();
+                const strB = (bValue || '').toString().toLowerCase();
+                return criteria.order === 'asc' ? strA.localeCompare(strB) : strB.localeCompare(strA);
+            }
+        });
+    }).value;
+}
+
+/**
+ * Object defining available screen sizes as constants.
+ * @readonly
+ */
+const sizeEnum = {
+    XS: 'XS',
+    SM: 'SM',
+    MD: 'MD',
+    LG: 'LG',
+    XL: 'XL',
+    XXL: 'XXL',
+};
+/**
+ * Object defining breakpoints for design based on screen width.
+ * Values are in pixels.
+ * @readonly
+ */
+const screenEnum = {
+    XS: 480,
+    SM: 576,
+    MD: 768,
+    LG: 992,
+    XL: 1200,
+    XXL: 1600,
+};
+/**
+ * Map that associates each screen size defined in `sizeEnum` with its corresponding pixel value from `screenEnum`.
+ * @type {Map<typeof sizeEnum[keyof typeof sizeEnum], number>}
+ */
+const screenMap = new Map();
+screenMap.set(sizeEnum.XS, screenEnum.XS);
+screenMap.set(sizeEnum.SM, screenEnum.SM);
+screenMap.set(sizeEnum.MD, screenEnum.MD);
+screenMap.set(sizeEnum.LG, screenEnum.LG);
+screenMap.set(sizeEnum.XL, screenEnum.XL);
+screenMap.set(sizeEnum.XXL, screenEnum.XXL);
+
+/**
+ * Object defining various exception codes.
+ * @readonly
+ */
+const ExceptionEnum = {
+    /**
+     * HTTP status code for page access forbidden.
+     */
+    PAGE_NOT_ACCESS: 403,
+    /**
+     * HTTP status code for page not found.
+     */
+    PAGE_NOT_FOUND: 404,
+    /**
+     * HTTP status code for general server error.
+     */
+    ERROR: 500,
+    /**
+     * HTTP status code for bad request.
+     */
+    BAD_REQUEST: 406,
+    /**
+     * Custom error code for network errors.
+     */
+    NET_WORK_ERROR: 10000,
+    /**
+     * Custom code indicating no data on the page, not actually an exception page.
+     */
+    PAGE_NOT_DATA: 10100,
+};
+
+/**
+ * Object defining various image MIME types.
+ * @readonly
+ */
+const ImageTypes = {
+    apng: 'image/apng',
+    bmp: 'image/bmp',
+    gif: 'image/gif',
+    jpeg: 'image/jpeg',
+    pjpeg: 'image/pjpeg',
+    png: 'image/png',
+    svg: 'image/svg+xml',
+    tiff: 'image/tiff',
+    webp: 'image/webp',
+    xicon: 'image/x-icon',
+};
+/**
+ * Object defining various file meta types.
+ * @readonly
+ */
+const FileMetaTypes = {
+    images: 'image/*',
+    audios: 'audio/*',
+    videos: 'video/*',
+};
+
+/**
+ * Object representing different content types for HTTP headers.
+ * @readonly
+ */
+const ContentTypeEnum = {
+    /**
+     * Content type for JSON.
+     * @constant
+     */
+    JSON: 'application/json;charset=UTF-8',
+    /**
+     * Content type for URL-encoded form data.
+     * @constant
+     */
+    FORM_URLENCODED: 'application/x-www-form-urlencoded;charset=UTF-8',
+    /**
+     * Content type for multipart form data with file uploads.
+     * @constant
+     */
+    FORM_DATA: 'multipart/form-data;charset=UTF-8',
+};
+
+/**
+ * Object defining various key codes for keyboard events.
+ * @readonly
+ */
+const KeyCodeEnum = {
+    UP: 38,
+    DOWN: 40,
+    ENTER: 13,
+    ESC: 27,
+};
+
+/**
+ * Key used for storing the authentication token.
+ * @constant {string}
+ */
+const TOKEN_KEY = 'TOKEN__';
+/**
+ * Key used for storing the locale information.
+ * @constant {string}
+ */
+const LOCALE_KEY = 'LOCALE__';
+/**
+ * Key used for storing user information.
+ * @constant {string}
+ */
+const USER_INFO_KEY = 'USER__INFO__';
+/**
+ * Key used for storing role information.
+ * @constant {string}
+ */
+const ROLES_KEY = 'ROLES__KEY__';
+/**
+ * Key used for storing project configuration.
+ * @constant {string}
+ */
+const PROJ_CFG_KEY = 'PROJ__CFG__KEY__';
+/**
+ * Key used for storing lock information.
+ * @constant {string}
+ */
+const LOCK_INFO_KEY = 'LOCK__INFO__KEY__';
+/**
+ * Key used for base global local cache.
+ * @constant {string}
+ */
+const APP_LOCAL_CACHE_KEY = 'COMMON__LOCAL__KEY';
+/**
+ * Key used for base global session cache.
+ * @constant {string}
+ */
+const APP_SESSION_CACHE_KEY = 'COMMON__SESSION__KEY';
+/**
+ * Object defining types of cache storage.
+ * @readonly
+ */
+const CacheTypeEnum = {
+    /** Represents session storage */
+    SESSION: 0,
+    /** Represents local storage */
+    LOCAL: 1,
+};
+
+/**
+ * Creates and downloads a file from Blob data.
+ * @param {Blob} blob The Blob containing the file data.
+ * @param {string} fileName The name of the file to create.
+ */
+function downloadFile(blob, fileName) {
+    const link = document.createElement('a');
+    const url = URL.createObjectURL(blob);
+    link.setAttribute('href', url);
+    link.setAttribute('download', fileName);
+    // Append link to the body and trigger a click
+    document.body.appendChild(link);
+    link.click();
+    // Clean up
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+}
+/**
+ * Exports data to a CSV file.
+ * @param {string[]} headers The headers for the CSV.
+ * @param {any[][]} data The data to export, as an array of arrays.
+ * @param {string} fileName The name of the file to create.
+ */
+function exportToCSV(headers, data, fileName) {
+    const csvRows = [];
+    // Add the headers
+    csvRows.push(headers.map(header => `"${header.replace(/"/g, '""')}"`).join(','));
+    // Add the data rows
+    for (const row of data) {
+        csvRows.push(row.map(cell => `"${String(cell).replace(/"/g, '""')}"`).join(','));
+    }
+    // Create a Blob with CSV data
+    const csvContent = csvRows.join('\n');
+    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+    // Use the download utility function
+    downloadFile(blob, fileName);
+}
+/**
+ * Exports data to an Excel file (.xls) using HTML table.
+ * @param {string[]} headers The headers for the Excel file.
+ * @param {any[][]} data The data to export, as an array of arrays.
+ * @param {string} fileName The name of the file to create.
+ */
+function exportToExcel(headers, data, fileName) {
+    // Create a table element
+    const table = document.createElement('table');
+    const thead = table.createTHead();
+    const tbody = table.createTBody();
+    // Create the header row
+    const headerRow = thead.insertRow();
+    headers.forEach(header => {
+        const th = document.createElement('th');
+        th.textContent = header;
+        headerRow.appendChild(th);
+    });
+    // Create the data rows
+    data.forEach(row => {
+        const tr = tbody.insertRow();
+        row.forEach(cell => {
+            const td = tr.insertCell();
+            td.textContent = String(cell);
+        });
+    });
+    // Create a Blob with the table HTML
+    const html = table.outerHTML;
+    const blob = new Blob([html], { type: 'application/vnd.ms-excel;charset=utf-8;' });
+    // Use the download utility function
+    downloadFile(blob, fileName);
+}
+/**
+ * Exports data to a JSON file.
+ * @param {any[]} data The data to export.
+ * @param {string} fileName The name of the file to create.
+ */
+function exportToJSON(data, fileName) {
+    const jsonContent = JSON.stringify(data, null, 2); // Pretty print with 2 spaces
+    const blob = new Blob([jsonContent], { type: 'application/json;charset=utf-8;' });
+    // Use the download utility function
+    downloadFile(blob, fileName);
+}
+/**
+ * Exports data to an XML file.
+ * @param {string[]} headers The headers for the XML.
+ * @param {any[][]} data The data to export, as an array of arrays.
+ * @param {string} fileName The name of the file to create.
+ */
+function exportToXML(headers, data, fileName) {
+    let xmlContent = '<?xml version="1.0" encoding="UTF-8"?>\n<rows>\n';
+    // Add headers
+    xmlContent += '  <header>\n';
+    headers.forEach(header => {
+        xmlContent += `    <column>${header}</column>\n`;
+    });
+    xmlContent += '  </header>\n';
+    // Add data rows
+    data.forEach(row => {
+        xmlContent += '  <row>\n';
+        row.forEach(cell => {
+            xmlContent += `    <cell>${cell}</cell>\n`;
+        });
+        xmlContent += '  </row>\n';
+    });
+    xmlContent += '</rows>';
+    const blob = new Blob([xmlContent], { type: 'application/xml;charset=utf-8;' });
+    // Use the download utility function
+    downloadFile(blob, fileName);
+}
+/**
+ * Exports data to a plain text file.
+ * @param {string[]} headers The headers for the text file.
+ * @param {any[][]} data The data to export, as an array of arrays.
+ * @param {string} fileName The name of the file to create.
+ */
+function exportToText(headers, data, fileName) {
+    const textRows = [];
+    // Add headers
+    textRows.push(headers.join('\t'));
+    // Add data rows
+    data.forEach(row => {
+        textRows.push(row.join('\t'));
+    });
+    // Create a Blob with text data
+    const textContent = textRows.join('\n');
+    const blob = new Blob([textContent], { type: 'text/plain;charset=utf-8;' });
+    // Use the download utility function
+    downloadFile(blob, fileName);
+}
+
+/**
+ * Opens a new window with the specified URL and options.
+ * @param {string} url The URL to open.
+ * @param {Object} [opt] Options for the new window.
+ * @param {string} [opt.target='__blank'] The target window name.
+ * @param {boolean} [opt.noopener=true] Whether to add 'noopener' attribute.
+ * @param {boolean} [opt.noreferrer=true] Whether to add 'noreferrer' attribute.
+ */
+function openWindow(url, opt) {
+    const { target = '__blank', noopener = true, noreferrer = true } = opt || {};
+    const features = [];
+    // Append noopener and noreferrer attributes if enabled
+    if (noopener)
+        features.push('noopener=yes');
+    if (noreferrer)
+        features.push('noreferrer=yes');
+    // Open the window with the specified features
+    window.open(url, target, features.join(','));
+}
+/**
+ * Copies text to the clipboard.
+ * @param {string} text The text to copy.
+ * @returns {Promise<void>} A promise that resolves when the text has been copied.
+ */
+async function copyToClipboard(text) {
+    if (navigator.clipboard) {
+        await navigator.clipboard.writeText(text);
+    }
+    else {
+        // Fallback for browsers that do not support the Clipboard API
+        const textArea = document.createElement('textarea');
+        textArea.value = text;
+        document.body.appendChild(textArea);
+        textArea.select();
+        document.execCommand('copy');
+        document.body.removeChild(textArea);
+    }
+}
+/**
+ * Scrolls the window to the top smoothly.
+ * @param {number} [duration=300] Duration of the scroll animation in milliseconds.
+ */
+function scrollToTop(duration = 300) {
+    const start = window.scrollY;
+    const startTime = performance.now();
+    function scroll() {
+        const elapsed = performance.now() - startTime;
+        const progress = Math.min(elapsed / duration, 1);
+        window.scrollTo(0, start * (1 - progress));
+        if (progress < 1) {
+            requestAnimationFrame(scroll);
+        }
+    }
+    requestAnimationFrame(scroll);
+}
+/**
+ * Gets the value of a query parameter from the URL.
+ * @param {string} paramName The name of the query parameter.
+ * @returns {string | null} The value of the query parameter, or null if it does not exist.
+ */
+function getQueryParam(paramName) {
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.get(paramName);
+}
+
+/**
+ * Disables the right-click context menu on the window.
+ */
+function disableRightClick() {
+    const handler = (event) => event.preventDefault();
+    window.addEventListener('contextmenu', handler);
+    // Store handler to allow removal
+    disableRightClick.handler = handler;
+}
+disableRightClick.handler = null;
+/**
+ * Enables the right-click context menu on the window.
+ */
+function enableRightClick() {
+    if (disableRightClick.handler) {
+        window.removeEventListener('contextmenu', disableRightClick.handler);
+    }
+}
+/**
+ * Disables specific mouse buttons.
+ * @param {Array<number>} buttons Array of mouse button codes to disable (0 for left, 1 for middle, 2 for right).
+ */
+function disableMouseButtons(buttons) {
+    const handler = (event) => {
+        if (buttons.includes(event.button)) {
+            event.preventDefault();
+        }
+    };
+    window.addEventListener('mousedown', handler);
+    window.addEventListener('contextmenu', handler); // Also handles right-click context menu
+    // Store handler to allow removal later
+    disableMouseButtons.handlers.push(handler);
+}
+disableMouseButtons.handlers = [];
+/**
+ * Enables all previously disabled mouse buttons.
+ */
+function enableMouseButtons() {
+    for (const handler of disableMouseButtons.handlers) {
+        window.removeEventListener('mousedown', handler);
+        window.removeEventListener('contextmenu', handler);
+    }
+    disableMouseButtons.handlers = [];
+}
+/**
+ * Adds a double-click event listener to a specific element.
+ * @param {HTMLElement} element The target element.
+ * @param {(event: MouseEvent) => void} callback The callback function to execute on double click.
+ */
+function addDoubleClickListener(element, callback) {
+    element.addEventListener('dblclick', callback);
+}
+/**
+ * Removes a double-click event listener from a specific element.
+ * @param {HTMLElement} element The target element.
+ * @param {(event: MouseEvent) => void} callback The callback function to remove.
+ */
+function removeDoubleClickListener(element, callback) {
+    element.removeEventListener('dblclick', callback);
+}
+// Example usage:
+// addDoubleClickListener(document.body, () => alert('Double clicked!'));
+/**
+ * Detects a click outside a specific element and triggers a callback.
+ * @param {HTMLElement} element The element to detect clicks outside of.
+ * @param {() => void} callback The callback function to execute when a click outside is detected.
+ */
+function clickOutside(element, callback) {
+    const handler = (event) => {
+        if (!element.contains(event.target)) {
+            callback();
+        }
+    };
+    document.addEventListener('click', handler);
+    // Store handler to allow removal later
+    clickOutside.handlers.push({ element, handler });
+}
+clickOutside.handlers = [];
+/**
+ * Removes the click outside listener for a specific element.
+ * @param {HTMLElement} element The element to stop detecting clicks outside of.
+ */
+function removeClickOutside(element) {
+    const index = clickOutside.handlers.findIndex(h => h.element === element);
+    if (index !== -1) {
+        document.removeEventListener('click', clickOutside.handlers[index].handler);
+        clickOutside.handlers.splice(index, 1);
+    }
+}
+// Example usage: Close a menu when clicking outside of it
+// const menu = document.getElementById('menu');
+// if (menu) {
+//     clickOutside(menu, () => menu.style.display = 'none');
+// }
+/**
+ * Disables the F12 key and certain key combinations for developer tools.
+ */
+function disableF12Key() {
+    const handler = function (event) {
+        return true;
+    };
+    document.addEventListener('keydown', handler);
+}
+/**
+ * Enables or disables the tab navigation (Tab key) on the page.
+ * @param {boolean} enable Whether to enable or disable tab navigation.
+ */
+function toggleTabNavigation(enable) {
+    if (enable) {
+        document.onkeydown = null; // Removes any previously set handler
+    }
+    else {
+        document.onkeydown = (event) => {
+            if (event.key === 'Tab') {
+                event.preventDefault();
+                return false;
+            }
+            return true;
+        };
+    }
+}
+/**
+ * Disables the copy (Ctrl + C) functionality on the page.
+ */
+function disableCopy() {
+    document.addEventListener('copy', (event) => {
+        event.preventDefault();
+        alert('Copying text is disabled on this page.');
+    });
+}
+/**
+ * Adds a custom keyboard shortcut to execute a given callback function.
+ * @param {string} key The key to trigger the callback.
+ * @param {Function} callback The function to execute on the key press.
+ * @param {boolean} [ctrlKey=false] Whether Ctrl key should be pressed.
+ * @param {boolean} [shiftKey=false] Whether Shift key should be pressed.
+ */
+function addCustomKeyboardShortcut(key, callback, ctrlKey = false, shiftKey = false) {
+    document.addEventListener('keydown', (event) => {
+        if (event.key === key &&
+            event.ctrlKey === ctrlKey &&
+            event.shiftKey === shiftKey) {
+            event.preventDefault();
+            callback();
+        }
+    });
+}
+/**
+ * Removes a custom keyboard shortcut by key and modifiers.
+ * @param {string} key The key to trigger the callback.
+ * @param {boolean} [ctrlKey=false] Whether Ctrl key should be pressed.
+ * @param {boolean} [shiftKey=false] Whether Shift key should be pressed.
+ */
+function removeCustomKeyboardShortcut(key, ctrlKey = false, shiftKey = false) {
+    const handler = (event) => {
+        if (event.key === key &&
+            event.ctrlKey === ctrlKey &&
+            event.shiftKey === shiftKey) {
+            event.preventDefault();
+        }
+    };
+    document.removeEventListener('keydown', handler);
+}
+/**
+ * Disables specific keys or key combinations.
+ * @param {Array<string>} keys Array of key names to disable (e.g., ['F1', 'F5', 'Control+S']).
+ */
+function disableSpecificKeys(keys) {
+    const handler = (event) => {
+        const keyCombination = `${event.ctrlKey ? 'Control+' : ''}${event.shiftKey ? 'Shift+' : ''}${event.altKey ? 'Alt+' : ''}${event.key}`;
+        if (keys.includes(event.key) || keys.includes(keyCombination)) {
+            event.preventDefault();
+        }
+    };
+    document.addEventListener('keydown', handler);
+    // Storing the handler to allow removal later
+    disableSpecificKeys.handlers.push(handler);
+}
+disableSpecificKeys.handlers = [];
+/**
+ * Enables keys that were previously disabled using disableSpecificKeys.
+ */
+function enableSpecificKeys() {
+    for (const handler of disableSpecificKeys.handlers) {
+        document.removeEventListener('keydown', handler);
+    }
+    disableSpecificKeys.handlers = [];
+}
+/**
+ * Registers multiple keyboard shortcuts with their respective callback functions.
+ * @param {Array<{ key: string, ctrlKey?: boolean, shiftKey?: boolean, altKey?: boolean, callback: Function }>} shortcuts Array of shortcut objects.
+ */
+function registerKeyboardShortcuts(shortcuts) {
+    const handler = (event) => {
+        for (const shortcut of shortcuts) {
+            if (event.key === shortcut.key &&
+                (shortcut.ctrlKey ? event.ctrlKey : true) &&
+                (shortcut.shiftKey ? event.shiftKey : true) &&
+                (shortcut.altKey ? event.altKey : true)) {
+                event.preventDefault();
+                shortcut.callback();
+            }
+        }
+    };
+    document.addEventListener('keydown', handler);
+    // Storing the handler to allow removal later
+    registerKeyboardShortcuts.handlers.push(handler);
+}
+registerKeyboardShortcuts.handlers = [];
+/**
+ * Unregisters all keyboard shortcuts that were registered with registerKeyboardShortcuts.
+ */
+function unregisterKeyboardShortcuts() {
+    for (const handler of registerKeyboardShortcuts.handlers) {
+        document.removeEventListener('keydown', handler);
+    }
+    registerKeyboardShortcuts.handlers = [];
+}
+/**
+ * Adds a listener for a specific key to trigger a custom event.
+ * @param {string} key The key to listen for (e.g., 'Enter', 'Escape').
+ * @param {Function} callback The function to execute when the key is pressed.
+ */
+function addKeyListener(key, callback) {
+    const handler = (event) => {
+        if (event.key === key) {
+            event.preventDefault();
+            callback();
+        }
+    };
+    document.addEventListener('keydown', handler);
+    // Storing the handler to allow removal later
+    addKeyListener.handlers.push(handler);
+}
+addKeyListener.handlers = [];
+/**
+ * Removes all custom key listeners added by addKeyListener.
+ */
+function removeKeyListeners() {
+    for (const handler of addKeyListener.handlers) {
+        document.removeEventListener('keydown', handler);
+    }
+    addKeyListener.handlers = [];
+}
+/**
+ * Detects if a specific key is held down.
+ * @param {string} key The key to detect (e.g., 'Shift', 'Control', 'Alt', 'a').
+ * @param {Function} onHold Callback function to execute while the key is held down.
+ */
+function detectKeyHold(key, onHold) {
+    const keyDownHandler = (event) => {
+        if (event.key === key) {
+            onHold();
+        }
+    };
+    document.addEventListener('keydown', keyDownHandler);
+    // Storing the handler to allow removal later
+    detectKeyHold.handlers.push(keyDownHandler);
+}
+detectKeyHold.handlers = [];
+/**
+ * Stops detecting if a specific key is held down.
+ */
+function stopDetectingKeyHold() {
+    for (const handler of detectKeyHold.handlers) {
+        document.removeEventListener('keydown', handler);
+    }
+    detectKeyHold.handlers = [];
+}
+/**
+ * Tracks currently pressed keys and provides a map of active keys.
+ * @returns {Set<string>} A set of currently pressed keys.
+ */
+function createKeyMap() {
+    const pressedKeys = new Set();
+    const keyDownHandler = (event) => {
+        pressedKeys.add(event.key);
+    };
+    const keyUpHandler = (event) => {
+        pressedKeys.delete(event.key);
+    };
+    document.addEventListener('keydown', keyDownHandler);
+    document.addEventListener('keyup', keyUpHandler);
+    // Function to remove listeners
+    createKeyMap.clearListeners = () => {
+        document.removeEventListener('keydown', keyDownHandler);
+        document.removeEventListener('keyup', keyUpHandler);
+    };
+    return pressedKeys;
+}
+/**
+ * Clears listeners for the key map tracking.
+ */
+createKeyMap.clearListeners = () => { };
+/**
+ * Sets up custom keyboard shortcuts with flexible order.
+ * @param {Array<string>} keys The combination of keys for the shortcut.
+ * @param {Function} callback The callback function to execute when the combination is detected.
+ */
+function customShortcut(keys, callback) {
+    const pressedKeys = new Set();
+    const keyDownHandler = (event) => {
+        pressedKeys.add(event.key);
+        if (keys.every(key => pressedKeys.has(key))) {
+            callback();
+        }
+    };
+    const keyUpHandler = (event) => {
+        pressedKeys.delete(event.key);
+    };
+    document.addEventListener('keydown', keyDownHandler);
+    document.addEventListener('keyup', keyUpHandler);
+    // Store the handlers for later removal
+    customShortcut.handlers.push({ keyDownHandler, keyUpHandler });
+}
+customShortcut.handlers = [];
+/**
+ * Removes all custom keyboard shortcuts added by customShortcut.
+ */
+function removeCustomShortcuts() {
+    for (const { keyDownHandler, keyUpHandler } of customShortcut.handlers) {
+        document.removeEventListener('keydown', keyDownHandler);
+        document.removeEventListener('keyup', keyUpHandler);
+    }
+    customShortcut.handlers = [];
+}
+/**
+ * Simulates a key press event.
+ * @param {string} key The key to simulate (e.g., 'Enter', 'a').
+ * @param {boolean} ctrlKey If true, include Ctrl key in the event.
+ * @param {boolean} shiftKey If true, include Shift key in the event.
+ * @param {boolean} altKey If true, include Alt key in the event.
+ */
+function simulateKeyPress(key, ctrlKey = false, shiftKey = false, altKey = false) {
+    const event = new KeyboardEvent('keydown', {
+        key,
+        ctrlKey,
+        shiftKey,
+        altKey,
+        bubbles: true,
+        cancelable: true
+    });
+    document.dispatchEvent(event);
+}
+
+/**
+ * Parses a date string into a Date object.
+ * @param {string} dateString The date string in 'YYYY-MM-DD' format.
+ * @returns {Date | null} The parsed Date object or null if the format is invalid.
+ */
+function parseDate(dateString) {
+    const parts = dateString.split('-');
+    if (parts.length === 3) {
+        const year = parseInt(parts[0], 10);
+        const month = parseInt(parts[1], 10) - 1; // Months are zero-based
+        const day = parseInt(parts[2], 10);
+        const date = new Date(year, month, day);
+        if (date.getFullYear() === year && date.getMonth() === month && date.getDate() === day) {
+            return date;
+        }
+    }
+    return null;
+}
+/**
+ * Formats a Date object into a string.
+ * @param {Date} date The date to format.
+ * @param {string} format The format string (e.g., 'YYYY-MM-DD').
+ * @returns {string} The formatted date string.
+ */
+function formatDate(date, format) {
+    const map = {
+        'YYYY': date.getFullYear(),
+        'MM': String(date.getMonth() + 1).padStart(2, '0'),
+        'DD': String(date.getDate()).padStart(2, '0'),
+        'HH': String(date.getHours()).padStart(2, '0'),
+        'mm': String(date.getMinutes()).padStart(2, '0'),
+        'ss': String(date.getSeconds()).padStart(2, '0')
+    };
+    return format.replace(/YYYY|MM|DD|HH|mm|ss/g, (matched) => (map[matched] || matched).toString());
+}
+/**
+ * Calculates the number of days between two dates.
+ * @param {Date} startDate The start date.
+ * @param {Date} endDate The end date.
+ * @returns {number} The number of days between the two dates.
+ */
+function daysBetween(startDate, endDate) {
+    const millisecondsPerDay = 86400000; // Number of milliseconds in one day
+    return Math.round((endDate.getTime() - startDate.getTime()) / millisecondsPerDay);
+}
+/**
+ * Adds a specified number of days to a date.
+ * @param {Date} date The date to modify.
+ * @param {number} days The number of days to add.
+ * @returns {Date} The new date with days added.
+ */
+function addDays(date, days) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+}
+/**
+ * Subtracts a specified number of days from a date.
+ * @param {Date} date The date to modify.
+ * @param {number} days The number of days to subtract.
+ * @returns {Date} The new date with days subtracted.
+ */
+function subtractDays(date, days) {
+    return addDays(date, -days);
+}
+/**
+ * Determines if a year is a leap year.
+ * @param {number} year The year to check.
+ * @returns {boolean} True if the year is a leap year, false otherwise.
+ */
+function isLeapYear(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
+}
+/**
+ * Gets the first day of the month for a given date.
+ * @param {Date} date The date to use.
+ * @returns {Date} The first day of the month.
+ */
+function getStartOfMonth(date) {
+    return new Date(date.getFullYear(), date.getMonth(), 1);
+}
+/**
+ * Gets the last day of the month for a given date.
+ * @param {Date} date The date to use.
+ * @returns {Date} The last day of the month.
+ */
+function getEndOfMonth(date) {
+    return new Date(date.getFullYear(), date.getMonth() + 1, 0);
+}
+/**
+ * Calculates age from a given birth date.
+ * @param {Date} birthDate The birth date.
+ * @returns {number} The calculated age.
+ */
+function calculateAge(birthDate) {
+    const today = new Date();
+    let age = today.getFullYear() - birthDate.getFullYear();
+    const m = today.getMonth() - birthDate.getMonth();
+    if (m < 0 || (m === 0 && today.getDate() < birthDate.getDate())) {
+        age--;
+    }
+    return age;
+}
+/**
+ * Calculates the number of days until the next birthday.
+ * @param {Date} birthDate The birth date.
+ * @returns {number} The number of days until the next birthday.
+ */
+function daysToNextBirthday(birthDate) {
+    const today = new Date();
+    const currentYear = today.getFullYear();
+    const nextBirthday = new Date(birthDate);
+    nextBirthday.setFullYear(currentYear);
+    if (nextBirthday < today) {
+        nextBirthday.setFullYear(currentYear + 1);
+    }
+    return daysBetween(today, nextBirthday);
+}
+/**
+ * Calculates the age at a specific date.
+ * @param {Date} birthDate The birth date.
+ * @param {Date} atDate The date to calculate the age at.
+ * @returns {number} The calculated age.
+ */
+function ageAtDate(birthDate, atDate) {
+    let age = atDate.getFullYear() - birthDate.getFullYear();
+    const m = atDate.getMonth() - birthDate.getMonth();
+    if (m < 0 || (m === 0 && atDate.getDate() < birthDate.getDate())) {
+        age--;
+    }
+    return age;
+}
+
+/**
+ * Creates a debounced asynchronous validator function.
+ *
+ * @param validator - The async validator function to debounce.
+ * @param delay - The debounce delay in milliseconds.
+ * @returns A debounced version of the validator function.
+ */
+function debounceAsyncValidator(validator, delay) {
+    let currentPromiseReject = null;
+    /**
+     * Creates a debounce delay.
+     *
+     * @returns A promise that resolves after the debounce delay.
+     */
+    function debounce() {
+        return new Promise((resolve, reject) => {
+            const { start, stop } = useTimeoutFn(() => {
+                currentPromiseReject = null;
+                resolve();
+            }, delay);
+            if (currentPromiseReject) {
+                currentPromiseReject(new Error('replaced'));
+            }
+            currentPromiseReject = reject;
+            start();
+        });
+    }
+    return function (value) {
+        if (currentPromiseReject) {
+            currentPromiseReject(new Error('replaced'));
+            currentPromiseReject = null;
+        }
+        return validator.call(this, value, debounce);
+    };
+}
+/**
+ * Creates a debounced version of an asynchronous function.
+ * @param {Function} func The asynchronous function to debounce.
+ * @param {number} wait The number of milliseconds to wait before invoking the function.
+ * @returns {Function} The debounced function.
+ */
+function debounceAsync(func, wait) {
+    let timeoutReject = null;
+    return function (...args) {
+        if (timeoutReject) {
+            timeoutReject(new Error('replaced'));
+            timeoutReject = null;
+        }
+        return new Promise((resolve, reject) => {
+            const { start } = useTimeoutFn(() => {
+                func.apply(this, args).then(resolve).catch(reject);
+            }, wait);
+            timeoutReject = reject;
+            start();
+        });
+    };
+}
+/**
+ * Creates a debounced asynchronous function that executes immediately on the first call.
+ * @param {Function} func The asynchronous function to debounce.
+ * @param {number} wait The number of milliseconds to wait before invoking the function.
+ * @returns {Function} The debounced function with immediate execution on the first call.
+ */
+function debounceAsyncWithImmediate(func, wait) {
+    let timeoutReject = null;
+    let callNow = true;
+    return function (...args) {
+        const context = this;
+        if (callNow) {
+            callNow = false;
+            return func.apply(context, args).finally(() => {
+                const { start } = useTimeoutFn(() => {
+                    callNow = true;
+                }, wait);
+                start();
+            });
+        }
+        else {
+            if (timeoutReject) {
+                timeoutReject(new Error('replaced'));
+                timeoutReject = null;
+            }
+            return new Promise((resolve, reject) => {
+                const { start } = useTimeoutFn(() => {
+                    func.apply(context, args).then(resolve).catch(reject);
+                }, wait);
+                timeoutReject = reject;
+                start();
+            });
+        }
+    };
+}
+/**
+ * Creates a debounced version of a function that executes on the leading edge.
+ * @param {Function} func The function to debounce.
+ * @param {number} wait The number of milliseconds to wait before invoking the function.
+ * @returns {Function} The debounced function.
+ */
+function debounceLeading(func, wait) {
+    let timeoutReject = null;
+    return function (...args) {
+        const context = this;
+        if (!timeoutReject) {
+            func.apply(context, args);
+        }
+        if (timeoutReject) {
+            timeoutReject(new Error('replaced'));
+            timeoutReject = null;
+        }
+        const { start } = useTimeoutFn(() => {
+            timeoutReject = null;
+        }, wait);
+        timeoutReject = () => { };
+        start();
+    };
+}
+/**
+ * Creates a debounced version of a function that executes on the trailing edge.
+ * @param {Function} func The function to debounce.
+ * @param {number} wait The number of milliseconds to wait before invoking the function.
+ * @returns {Function} The debounced function.
+ */
+function debounceTrailing(func, wait) {
+    let timeoutReject = null;
+    return function (...args) {
+        const context = this;
+        if (timeoutReject) {
+            timeoutReject(new Error('replaced'));
+            timeoutReject = null;
+        }
+        const { start } = useTimeoutFn(() => {
+            func.apply(context, args);
+        }, wait);
+        timeoutReject = () => { };
+        start();
+    };
+}
+/**
+ * Creates a debounced version of a function that executes on both leading and trailing edges.
+ * @param {Function} func The function to debounce.
+ * @param {number} wait The number of milliseconds to wait before invoking the function.
+ * @returns {Function} The debounced function.
+ */
+function debounceLeadingTrailing(func, wait) {
+    let timeoutReject = null;
+    let lastCall = 0;
+    return function (...args) {
+        const context = this;
+        const now = Date.now();
+        if (timeoutReject) {
+            timeoutReject(new Error('replaced'));
+            timeoutReject = null;
+        }
+        if (now - lastCall >= wait) {
+            func.apply(context, args);
+            lastCall = now;
+        }
+        else {
+            const { start } = useTimeoutFn(() => {
+                func.apply(context, args);
+            }, wait - (now - lastCall));
+            timeoutReject = () => { };
+            start();
+        }
+    };
+}
+/**
+ * Creates a debounced version of a function.
+ * @param {Function} func The function to debounce.
+ * @param {number} wait The number of milliseconds to wait before invoking the function.
+ * @returns {Function} The debounced function.
+ */
+function debounce(func, wait) {
+    let timeoutReject = null;
+    return function (...args) {
+        if (timeoutReject) {
+            timeoutReject(new Error('replaced'));
+            timeoutReject = null;
+        }
+        const { start } = useTimeoutFn(() => {
+            func.apply(this, args);
+        }, wait);
+        timeoutReject = () => { };
+        start();
+    };
+}
+/**
+ * Creates a throttled version of a function.
+ * @param {Function} func The function to throttle.
+ * @param {number} limit The number of milliseconds to wait between function calls.
+ * @returns {Function} The throttled function.
+ */
+function throttle(func, limit) {
+    let lastCall = 0;
+    return function (...args) {
+        const now = Date.now();
+        if (now - lastCall >= limit) {
+            lastCall = now;
+            func.apply(this, args);
+        }
+    };
+}
+
+/**
+ * Converts a FormData object to a plain JavaScript object.
+ * @param {FormData} formData The FormData object to convert.
+ * @returns {Record<string, any>} The plain JavaScript object.
+ */
+function formDataToObject(formData) {
+    const obj = {};
+    formData.forEach((value, key) => {
+        // Handle multiple values for the same key
+        if (obj[key]) {
+            if (!Array.isArray(obj[key])) {
+                obj[key] = [obj[key]];
+            }
+            obj[key].push(value);
+        }
+        else {
+            obj[key] = value;
+        }
+    });
+    return obj;
+}
+/**
+ * Reads a file as text.
+ * @param {File} file The file to read.
+ * @returns {Promise<string>} A promise that resolves with the file content.
+ */
+function readFileAsText(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsText(file);
+    });
+}
+/**
+ * Reads a file as a Data URL.
+ * @param {File} file The file to read.
+ * @returns {Promise<string>} A promise that resolves with the Data URL.
+ */
+function readFileAsDataURL(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
+}
+/**
+ * Creates a Blob from a string.
+ * @param {string} content The string content for the Blob.
+ * @param {string} [type='text/plain'] The MIME type of the Blob.
+ * @returns {Blob} The Blob object.
+ */
+function stringToBlob(content, type = 'text/plain') {
+    return new Blob([content], { type });
+}
+/**
+ * Creates a Blob from an ArrayBuffer.
+ * @param {ArrayBuffer} buffer The ArrayBuffer to convert.
+ * @param {string} [type='application/octet-stream'] The MIME type of the Blob.
+ * @returns {Blob} The Blob object.
+ */
+function bufferToBlob(buffer, type = 'application/octet-stream') {
+    return new Blob([buffer], { type });
+}
+/**
+ * Creates and downloads a file from Blob data.
+ * @param {Blob} blob The Blob containing the file data.
+ * @param {string} fileName The name of the file to create.
+ */
+function downloadBlob(blob, fileName) {
+    const link = document.createElement('a');
+    const url = URL.createObjectURL(blob);
+    link.setAttribute('href', url);
+    link.setAttribute('download', fileName);
+    // Append link to the body and trigger a click
+    document.body.appendChild(link);
+    link.click();
+    // Clean up
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+}
+/**
+ * Creates a FormData object containing a Blob.
+ * @param {Blob} blob The Blob to include in the FormData.
+ * @param {string} name The name of the form field.
+ * @param {string} [fileName='file'] The file name for the Blob.
+ * @returns {FormData} The FormData object.
+ */
+function blobToFormData(blob, name, fileName = 'file') {
+    const formData = new FormData();
+    formData.append(name, blob, fileName);
+    return formData;
+}
+
+/**
+ * Converts a Proxy object to a plain object.
+ * @param {ProxyConstructor} proxy The Proxy object to convert.
+ * @returns {Object} The plain object.
+ */
+function proxyToPlainObject(proxy) {
+    if (!proxy)
+        return {};
+    const plainObject = {};
+    for (const property of Object.keys(proxy)) {
+        plainObject[property] = proxy[property];
+    }
+    return plainObject;
+}
+/**
+ * Compares two objects to check if they have the same keys.
+ * @param {Object} object1 The first object to compare.
+ * @param {Object} object2 The second object to compare.
+ * @returns {boolean} True if the objects have the same keys, otherwise false.
+ */
+function compareObject(object1, object2) {
+    return Object.keys(object1).every(function (element) {
+        return Object.keys(object2).includes(element);
+    });
+}
+/**
+ * Deeply compares two objects to check if they are equal.
+ * @param {Object} object1 The first object to compare.
+ * @param {Object} object2 The second object to compare.
+ * @returns {boolean} True if the objects are deeply equal, otherwise false.
+ */
+function deepEqual(object1, object2) {
+    if (object1 === object2)
+        return true;
+    if (typeof object1 !== 'object' || typeof object2 !== 'object' || object1 === null || object2 === null) {
+        return false;
+    }
+    const keys1 = Object.keys(object1);
+    const keys2 = Object.keys(object2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!keys2.includes(key) || !deepEqual(object1[key], object2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Deeply clones an object.
+ * @param {Object} obj The object to clone.
+ * @returns {Object} The cloned object.
+ */
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof Array) {
+        return obj.map(item => deepClone(item));
+    }
+    if (obj instanceof Object) {
+        const copy = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                copy[key] = deepClone(obj[key]);
+            }
+        }
+        return copy;
+    }
+    throw new Error('Unable to clone object! Its type is not supported.');
+}
+/**
+ * Converts an object to a query string.
+ * @param {Object} obj The object to convert.
+ * @returns {string} The query string.
+ */
+function objectToQueryString(obj) {
+    return Object.keys(obj)
+        .map(key => encodeURIComponent(key) + '=' + encodeURIComponent(obj[key]))
+        .join('&');
+}
+// Example usage:
+// objectToQueryString({ name: 'John Doe', age: 30 }); // 'name=John%20Doe&age=30'
+/**
+ * Gets the differences between two objects.
+ * @param {Object} object1 The first object.
+ * @param {Object} object2 The second object.
+ * @returns {Object} An object containing the differences.
+ */
+function getObjectDifferences(object1, object2) {
+    const differences = {};
+    const keys = new Set([...Object.keys(object1), ...Object.keys(object2)]);
+    for (const key of keys) {
+        if (object1[key] !== object2[key]) {
+            differences[key] = { object1: object1[key], object2: object2[key] };
+        }
+    }
+    return differences;
+}
+/**
+ * Filters an object by a list of keys.
+ * @param {Object} obj The object to filter.
+ * @param {Array<string>} keys The keys to keep.
+ * @returns {Object} The filtered object.
+ */
+function filterObjectByKeys(obj, keys) {
+    const filteredObject = {};
+    for (const key of keys) {
+        if (key in obj) {
+            filteredObject[key] = obj[key];
+        }
+    }
+    return filteredObject;
+}
+// Example usage:
+// filterObjectByKeys({ name: 'John', age: 30, job: 'Developer' }, ['name', 'job']); // { name: 'John', job: 'Developer' }
+/**
+ * Deeply merges two objects.
+ * @param {Object} target The target object to merge into.
+ * @param {Object} source The source object to merge from.
+ * @returns {Object} The merged object.
+ */
+function deepMerge(target, source) {
+    if (target === null || typeof target !== 'object' || typeof source !== 'object') {
+        return target;
+    }
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            if (source[key] && typeof source[key] === 'object') {
+                if (target && !target[key]) {
+                    Object.assign(target, { [key]: {} });
+                }
+                deepMerge(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return target;
+}
+/**
+ * Checks if an object is empty.
+ * @param {Object} obj The object to check.
+ * @returns {boolean} True if the object is empty, otherwise false.
+ */
+function isEmptyObject(obj) {
+    return Object.keys(obj).length === 0;
+}
+/**
+ * Safely accesses nested properties in an object.
+ * @param {Object} obj The object to access.
+ * @param {Array<string>} keys The array of keys representing the path.
+ * @returns {any} The value at the nested path, or undefined if not found.
+ */
+function safeGet(obj, keys) {
+    return keys.reduce((acc, key) => (acc && acc[key] !== undefined) ? acc[key] : undefined, obj);
+}
+// Example usage:
+// safeGet({ a: { b: { c: 10 } } }, ['a', 'b', 'c']); // 10
+// safeGet({ a: { b: { c: 10 } } }, ['a', 'x', 'c']); // undefined
+/**
+ * Removes empty properties (null, undefined, or empty string) from an object.
+ * @param {Object} obj The object to clean.
+ * @returns {Object} A new object without empty properties.
+ */
+function removeEmptyProperties(obj) {
+    return Object.keys(obj)
+        .filter(key => obj[key] !== null && obj[key] !== undefined && obj[key] !== '')
+        .reduce((acc, key) => {
+        acc[key] = obj[key];
+        return acc;
+    }, {});
+}
+// Example usage:
+// removeEmptyProperties({ a: null, b: 2, c: undefined, d: '', e: 'hello' }); // { b: 2, e: 'hello' }
+/**
+ * Retrieves all keys of an object as an array.
+ * @param {Object} obj The object to retrieve keys from.
+ * @returns {Array<string>} The array of keys.
+ */
+function getObjectKeys(obj) {
+    return Object.keys(obj);
+}
+// Example usage:
+// getObjectKeys({ name: 'John', age: 30 }); // ['name', 'age']
+/**
+ * Checks if an object has nested properties.
+ * @param {Object} obj The object to check.
+ * @returns {boolean} True if there are nested properties, false otherwise.
+ */
+function hasNestedProperties(obj) {
+    return Object.values(obj).some(value => typeof value === 'object' && value !== null);
+}
+// Example usage:
+// hasNestedProperties({ a: 1, b: { c: 2 } }); // true
+// hasNestedProperties({ a: 1, b: 2 }); // false
+/**
+ * Converts an object to FormData, handling nested objects.
+ * @param {Object} obj The object to convert.
+ * @param {FormData} [formData] The FormData object to append to.
+ * @param {string} [parentKey] The parent key for nested objects.
+ * @returns {FormData} The FormData object.
+ */
+function objectToFormDataEnhanced(obj, formData = new FormData(), parentKey = '') {
+    Object.entries(obj).forEach(([key, value]) => {
+        const finalKey = parentKey ? `${parentKey}[${key}]` : key;
+        if (value && typeof value === 'object' && !(value instanceof File)) {
+            objectToFormDataEnhanced(value, formData, finalKey);
+        }
+        else {
+            formData.append(finalKey, value);
+        }
+    });
+    return formData;
+}
+// Example usage:
+// objectToFormDataEnhanced({ user: { name: 'John', age: 30 } });
+/**
+ * Converts a JavaScript object into FormData.
+ *
+ * @param obj - The object to be converted.
+ * @param form - An optional FormData instance to use.
+ * @param namespace - An optional namespace to use for nested objects.
+ * @returns The FormData instance with the object's key-value pairs.
+ */
+const objectToFormData = function (obj, form, namespace) {
+    const fd = form || new FormData();
+    let formKey;
+    for (const property in obj) {
+        if (obj[property] === undefined) {
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(obj, property)) {
+            if (namespace) {
+                formKey = `${namespace}[${property}]`;
+            }
+            else {
+                formKey = property;
+            }
+            if (typeof obj[property] === 'object' && !(obj[property] instanceof File)) {
+                // Recursively handle nested objects
+                objectToFormData(obj[property], fd, formKey);
+            }
+            else {
+                // Convert boolean values to 1/0
+                const value = obj[property] === true || obj[property] === false ? Number(obj[property]) : obj[property];
+                fd.append(formKey, value);
+            }
+        }
+    }
+    return fd;
+};
+/**
+ * Flattens a nested object, bringing all properties to the top level.
+ * @param {Object} obj The object to flatten.
+ * @param {string} [parentKey] The parent key for nested properties.
+ * @param {Object} [result] The resulting flattened object.
+ * @returns {Object} The flattened object.
+ */
+function flattenObject(obj, parentKey = '', result = {}) {
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            const propName = parentKey ? `${parentKey}.${key}` : key;
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                flattenObject(obj[key], propName, result);
+            }
+            else {
+                result[propName] = obj[key];
+            }
+        }
+    }
+    return result;
+}
+// Example usage:
+// flattenObject({ a: 1, b: { c: 2, d: { e: 3 } } }); // { 'a': 1, 'b.c': 2, 'b.d.e': 3 }
+
+/**
+ * Capitalizes the first character of a string.
+ * @param {string} s The string to capitalize.
+ * @returns {string} The capitalized string.
+ */
+function upperFirst(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+// Example usage:
+// console.log(upperFirst('hello')); // 'Hello'
+/**
+ * Lowercases the first character of a string.
+ * @param {string} s The string to lowercase.
+ * @returns {string} The lowercased string.
+ */
+function lowerFirst(s) {
+    return s.charAt(0).toLowerCase() + s.slice(1);
+}
+// Example usage:
+// console.log(lowerFirst('Hello')); // 'hello'
+/**
+ * Removes accents and special characters from a string and converts it to a URL-friendly format.
+ * @param {string} input The string to process.
+ * @returns {string} The processed string.
+ */
+function removeAccent(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "");
+}
+// Example usage:
+// console.log(removeAccent('Café du Nord')); // 'cafe-du-nord'
+/**
+ * Reverses a string.
+ * @param {string} str The string to reverse.
+ * @returns {string} The reversed string.
+ */
+function reverseString(str) {
+    return str.split('').reverse().join('');
+}
+// Example usage:
+// console.log(reverseString('hello')); // 'olleh'
+/**
+ * Counts the number of words in a string.
+ * @param {string} str The string to analyze.
+ * @returns {number} The word count.
+ */
+function countWords(str) {
+    return str.trim().split(/\s+/).length;
+}
+// Example usage:
+// console.log(countWords('Hello world!')); // 2
+/**
+ * Truncates a string to the specified length and adds ellipsis if necessary.
+ * @param {string} str The string to truncate.
+ * @param {number} maxLength The maximum length of the string.
+ * @returns {string} The truncated string.
+ */
+function truncateString(str, maxLength) {
+    return str.length > maxLength ? str.slice(0, maxLength) + '...' : str;
+}
+// Example usage:
+// console.log(truncateString('This is a long string', 10)); // 'This is a...'
+/**
+ * Converts a string to camel case.
+ * @param {string} str The string to convert.
+ * @returns {string} The camel cased string.
+ */
+function toCamelCase(str) {
+    return str
+        .toLowerCase()
+        .replace(/[^a-zA-Z0-9]+(.)/g, (match, chr) => chr.toUpperCase());
+}
+// Example usage:
+// console.log(toCamelCase('hello world example')); // 'helloWorldExample'
+/**
+ * Converts a string to kebab case.
+ * @param {string} str The string to convert.
+ * @returns {string} The kebab cased string.
+ */
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+// Example usage:
+// console.log(toKebabCase('Hello World Example')); // 'hello-world-example'
+/**
+ * Replaces all instances of a substring within a string.
+ * @param {string} str The original string.
+ * @param {string} find The substring to find.
+ * @param {string} replace The substring to replace with.
+ * @returns {string} The modified string.
+ */
+function replaceAll(str, find, replace) {
+    return str.split(find).join(replace);
+}
+// Example usage:
+// console.log(replaceAll('hello world', 'o', 'a')); // 'hella warld'
+/**
+ * Generates a random string of a specific length.
+ * @param {number} length The length of the string to generate.
+ * @returns {string} The random string.
+ */
+function generateRandomString(length) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+}
+// Example usage:
+// console.log(generateRandomString(10)); // 'A1b2C3d4E5'
+
+/**
+ * Validates if the key pressed is a valid letter or special character.
+ * @param {KeyboardEvent} e The keyboard event.
+ * @returns {boolean} True if the key is valid, otherwise false.
+ */
+function validateLetters(e) {
+    const key = e.keyCode;
+    const validKeys = [
+        ...Array.from({ length: 26 }, (_, i) => i + 65), // Letters A-Z
+        ...Array.from({ length: 26 }, (_, i) => i + 97), // Letters a-z
+        45, // Hyphen
+        32, // Space
+        241, // ñ
+        209, // Ñ
+        225, // á
+        233, // é
+        237, // í
+        243, // ó
+        250, // ú
+        193, // Á
+        201, // É
+        205, // Í
+        211, // Ó
+        218 // Ú
+    ];
+    if (validKeys.includes(key)) {
+        return true;
+    }
+    e.preventDefault();
+    return false;
+}
+// Example usage:
+// document.addEventListener('keydown', validateLetters);
+/**
+ * Validates if the key pressed is a valid alphanumeric character.
+ * @param {KeyboardEvent} e The keyboard event.
+ * @returns {boolean} True if the key is valid, otherwise false.
+ */
+function validateAlphanumeric(e) {
+    const key = e.keyCode;
+    const validKeys = [
+        ...Array.from({ length: 10 }, (_, i) => i + 48), // Numbers 0-9
+        ...Array.from({ length: 26 }, (_, i) => i + 65), // Letters A-Z
+        ...Array.from({ length: 26 }, (_, i) => i + 97), // Letters a-z
+        45, // Hyphen
+        95, // Underscore
+        32 // Space
+    ];
+    if (validKeys.includes(key)) {
+        return true;
+    }
+    e.preventDefault();
+    return false;
+}
+// Example usage:
+// document.addEventListener('keydown', validateAlphanumeric);
+/**
+ * Validates if the key pressed is a number.
+ * @param {KeyboardEvent} e The keyboard event.
+ * @returns {boolean} True if the key is a number, otherwise false.
+ */
+function validateNumbers(e) {
+    const key = e.keyCode;
+    if ((key >= 48 && key <= 57) || key === 46 || key === 8 || key === 37 || key === 39) {
+        return true;
+    }
+    e.preventDefault();
+    return false;
+}
+// Example usage:
+// document.addEventListener('keydown', validateNumbers);
+/**
+ * Validates if a phone number is valid.
+ * @param {string} phoneNumber The phone number to validate.
+ * @returns {boolean} True if the phone number is valid, otherwise false.
+ */
+function isValidPhoneNumber(phoneNumber) {
+    const phonePattern = /^[0-9]{10}$/; // Example pattern for 10-digit phone numbers
+    return phonePattern.test(phoneNumber);
+}
+// Example usage:
+// console.log(isValidPhoneNumber('1234567890')); // true
+// console.log(isValidPhoneNumber('123-456-7890')); // false
+/**
+ * Validates if a string is a valid email address.
+ * @param {string} email The email address to validate.
+ * @returns {boolean} True if the email address is valid, otherwise false.
+ */
+function isValidEmail(email) {
+    const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailPattern.test(email);
+}
+// Example usage:
+// console.log(isValidEmail('example@domain.com')); // true
+// console.log(isValidEmail('invalid-email')); // false
+/**
+ * Validates if a string is a valid URL.
+ * @param {string} url The URL to validate.
+ * @returns {boolean} True if the URL is valid, otherwise false.
+ */
+function isValidURL(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Example usage:
+// console.log(isValidURL('https://www.example.com')); // true
+// console.log(isValidURL('invalid-url')); // false
+/**
+ * Validates if a string is a valid date in YYYY-MM-DD format.
+ * @param {string} date The date string to validate.
+ * @returns {boolean} True if the date is valid, otherwise false.
+ */
+function isValidDate(date) {
+    const datePattern = /^\d{4}-\d{2}-\d{2}$/;
+    if (!datePattern.test(date))
+        return false;
+    const [year, month, day] = date.split('-').map(Number);
+    const dateObj = new Date(year, month - 1, day);
+    return dateObj.getFullYear() === year && dateObj.getMonth() === month - 1 && dateObj.getDate() === day;
+}
+// Example usage:
+// console.log(isValidDate('2024-08-31')); // true
+// console.log(isValidDate('2024-02-30')); // false
+/**
+ * Validates if a password meets certain strength criteria.
+ * @param {string} password The password to validate.
+ * @returns {boolean} True if the password is strong, otherwise false.
+ */
+function isStrongPassword(password) {
+    const minLength = 8;
+    const hasUpperCase = /[A-Z]/.test(password);
+    const hasLowerCase = /[a-z]/.test(password);
+    const hasNumbers = /[0-9]/.test(password);
+    const hasSpecialChars = /[!@#$%^&*(),.?":{}|<>]/.test(password);
+    return password.length >= minLength && hasUpperCase && hasLowerCase && hasNumbers && hasSpecialChars;
+}
+// Example usage:
+// console.log(isStrongPassword('Strong1@password')); // true
+// console.log(isStrongPassword('weakpass')); // false
+/**
+ * Validates a credit card number using the Luhn algorithm.
+ * @param {string} cardNumber The credit card number to validate.
+ * @returns {boolean} True if the credit card number is valid, otherwise false.
+ */
+function isValidCreditCard(cardNumber) {
+    const sanitized = cardNumber.replace(/\D/g, '');
+    let sum = 0;
+    let shouldDouble = false;
+    for (let i = sanitized.length - 1; i >= 0; i--) {
+        let digit = parseInt(sanitized.charAt(i), 10);
+        if (shouldDouble) {
+            digit *= 2;
+            if (digit > 9)
+                digit -= 9;
+        }
+        sum += digit;
+        shouldDouble = !shouldDouble;
+    }
+    return sum % 10 === 0;
+}
+// Example usage:
+// console.log(isValidCreditCard('4111111111111111')); // true
+// console.log(isValidCreditCard('1234567812345670')); // false
+/**
+ * Validates if a string is a valid hex color code.
+ * @param {string} color The color code to validate.
+ * @returns {boolean} True if the color code is valid, otherwise false.
+ */
+function isValidHexColor(color) {
+    const hexPattern = /^#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{3})$/;
+    return hexPattern.test(color);
+}
+// Example usage:
+// console.log(isValidHexColor('#FFFFFF')); // true
+// console.log(isValidHexColor('#FFF')); // true
+// console.log(isValidHexColor('#12345G')); // false
+/**
+ * Validates if a string is a valid time in HH:MM format.
+ * @param {string} time The time string to validate.
+ * @returns {boolean} True if the time is valid, otherwise false.
+ */
+function isValidTime(time) {
+    const timePattern = /^([01]\d|2[0-3]):([0-5]\d)$/;
+    return timePattern.test(time);
+}
+// Example usage:
+// console.log(isValidTime('14:30')); // true
+// console.log(isValidTime('25:00')); // false
+/**
+ * Validates if a string is a valid IPv4 address.
+ * @param {string} ip The IP address to validate.
+ * @returns {boolean} True if the IP address is valid, otherwise false.
+ */
+function isValidIP(ip) {
+    const ipPattern = /^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)$/;
+    return ipPattern.test(ip);
+}
+// Example usage:
+// console.log(isValidIP('192.168.1.1')); // true
+// console.log(isValidIP('999.999.999.999')); // false
+/**
+ * Validates if a string is a valid U.S. Social Security Number (SSN).
+ * @param {string} ssn The SSN to validate.
+ * @returns {boolean} True if the SSN is valid, otherwise false.
+ */
+function isValidSSN(ssn) {
+    const ssnPattern = /^\d{3}-\d{2}-\d{4}$/;
+    return ssnPattern.test(ssn);
+}
+// Example usage:
+// console.log(isValidSSN('123-45-6789')); // true
+// console.log(isValidSSN('123-45-678')); // false
+/**
+ * Validates if a string is a valid U.S. ZIP code.
+ * @param {string} zip The ZIP code to validate.
+ * @returns {boolean} True if the ZIP code is valid, otherwise false.
+ */
+function isValidZIP(zip) {
+    const zipPattern = /^\d{5}(-\d{4})?$/;
+    return zipPattern.test(zip);
+}
+// Example usage:
+// console.log(isValidZIP('12345')); // true
+// console.log(isValidZIP('12345-6789')); // true
+// console.log(isValidZIP('1234')); // false
+/**
+ * Validates if a string is a valid credit card expiry date in MM/YY format.
+ * @param {string} expiryDate The expiry date to validate.
+ * @returns {boolean} True if the expiry date is valid, otherwise false.
+ */
+function isValidExpiryDate(expiryDate) {
+    const expiryPattern = /^(0[1-9]|1[0-2])\/\d{2}$/;
+    if (!expiryPattern.test(expiryDate))
+        return false;
+    const [month, year] = expiryDate.split('/').map(Number);
+    const currentYear = new Date().getFullYear() % 100;
+    const currentMonth = new Date().getMonth() + 1;
+    return (year > currentYear) || (year === currentYear && month >= currentMonth);
+}
+// Example usage:
+// console.log(isValidExpiryDate('08/24')); // true
+// console.log(isValidExpiryDate('12/22')); // false
+/**
+ * Validates if a string is a valid 8-character hexadecimal color code (including alpha).
+ * @param {string} color The color code to validate.
+ * @returns {boolean} True if the color code is valid, otherwise false.
+ */
+function isValidHexColorAlpha(color) {
+    const hexPattern = /^#([0-9A-Fa-f]{8})$/;
+    return hexPattern.test(color);
+}
+// Example usage:
+// console.log(isValidHexColorAlpha('#RRGGBBAA')); // true
+// console.log(isValidHexColorAlpha('#FFFFFF')); // false
+/**
+ * Validates if a username meets specific criteria.
+ * @param {string} username The username to validate.
+ * @returns {boolean} True if the username is valid, otherwise false.
+ */
+function isValidUsername(username) {
+    const usernamePattern = /^[a-zA-Z0-9_]{3,16}$/; // 3 to 16 characters, letters, numbers, and underscores only
+    return usernamePattern.test(username);
+}
+// Example usage:
+// console.log(isValidUsername('user_name123')); // true
+// console.log(isValidUsername('us')); // false
+/**
+ * Validates if a string represents a valid age between 0 and 120.
+ * @param {string} age The age to validate.
+ * @returns {boolean} True if the age is valid, otherwise false.
+ */
+function isValidAge(age) {
+    const ageNumber = parseInt(age, 10);
+    return !isNaN(ageNumber) && ageNumber >= 0 && ageNumber <= 120;
+}
+// Example usage:
+// console.log(isValidAge('25')); // true
+// console.log(isValidAge('121')); // false
+/**
+ * Validates if a string is a valid hexadecimal number.
+ * @param {string} hex The hexadecimal number to validate.
+ * @returns {boolean} True if the number is valid, otherwise false.
+ */
+function isValidHexNumber(hex) {
+    const hexPattern = /^[0-9A-Fa-f]+$/;
+    return hexPattern.test(hex);
+}
+// Example usage:
+// console.log(isValidHexNumber('1A3F')); // true
+// console.log(isValidHexNumber('GHIJ')); // false
+
+export { APP_LOCAL_CACHE_KEY, APP_SESSION_CACHE_KEY, AxiosService, CacheTypeEnum, ContentTypeEnum, ExceptionEnum, FileMetaTypes, ImageTypes, KeyCodeEnum, LOCALE_KEY, LOCK_INFO_KEY, PROJ_CFG_KEY, ROLES_KEY, TOKEN_KEY, USER_INFO_KEY, addCustomKeyboardShortcut, addDays, addDoubleClickListener, addKeyListener, ageAtDate, blobToFormData, bufferToBlob, calculateAge, clickOutside, compareObject, copyToClipboard, countWords, createKeyMap, customShortcut, daysBetween, daysToNextBirthday, debounce, debounceAsync, debounceAsyncValidator, debounceAsyncWithImmediate, debounceLeading, debounceLeadingTrailing, debounceTrailing, deepClone, deepEqual, deepMerge, detectKeyHold, disableCopy, disableF12Key, disableMouseButtons, disableRightClick, disableSpecificKeys, downloadBlob, enableMouseButtons, enableRightClick, enableSpecificKeys, exportToCSV, exportToExcel, exportToJSON, exportToText, exportToXML, filterObjectByKeys, flattenObject, formDataToObject, formatDate, generateRandomString, getEndOfMonth, getObjectDifferences, getObjectKeys, getQueryParam, getStartOfMonth, hasNestedProperties, isEmptyObject, isLeapYear, isStrongPassword, isValidAge, isValidCreditCard, isValidDate, isValidEmail, isValidExpiryDate, isValidHexColor, isValidHexColorAlpha, isValidHexNumber, isValidIP, isValidPhoneNumber, isValidSSN, isValidTime, isValidURL, isValidUsername, isValidZIP, lowerFirst, objectToFormData, objectToFormDataEnhanced, objectToQueryString, openWindow, parseDate, proxyToPlainObject, readFileAsDataURL, readFileAsText, registerKeyboardShortcuts, removeAccent, removeClickOutside, removeCustomKeyboardShortcut, removeCustomShortcuts, removeDoubleClickListener, removeEmptyProperties, removeKeyListeners, replaceAll, reverseString, safeGet, screenEnum, screenMap, scrollToTop, simulateKeyPress, sizeEnum, stopDetectingKeyHold, stringToBlob, subtractDays, throttle, toCamelCase, toKebabCase, toggleTabNavigation, truncateString, unregisterKeyboardShortcuts, upperFirst, useSorter, validateAlphanumeric, validateLetters, validateNumbers };