@arex95/vue-core 1.1.35 → 1.1.37

package/dist/index.mjs

@@ -1,11 +1,182 @@
 import axios from 'axios';
+import { jwtDecode } from 'jwt-decode';
 import { useRouter } from 'vue-router';
 import { v4 } from 'uuid';
 import { useTimeoutFn, useBreakpoints, breakpointsTailwind, useWindowSize } from '@vueuse/core';
-import { jwtDecode } from 'jwt-decode';
 import { useQuery } from '@tanstack/vue-query';
 import { ref, watch, onServerPrefetch, onMounted, computed } from 'vue';
 
+let tokensConfig = Object.freeze({
+    ACCESS_TOKEN: "access_token",
+    REFRESH_TOKEN: "refresh_token",
+});
+/**
+ * Configures the global keys for access and refresh tokens.
+ * Once set, they cannot be modified.
+ *
+ * @param {TokenKeyConfig} config - An object containing the token keys.
+ * @param {string} config.accessTokenKey - The name of the key for the access token.
+ * @param {string} config.refreshTokenKey - The name of the key for the refresh token.
+ *
+ * @returns {void} Does not return anything, but freezes the token configuration object.
+ */
+function configTokenKeys(config) {
+    tokensConfig = Object.freeze({
+        ACCESS_TOKEN: config.accessTokenKey,
+        REFRESH_TOKEN: config.refreshTokenKey,
+    });
+}
+/**
+ * Retrieves the current token configuration.
+ *
+ * @returns {TokensConfig} The configuration of the access and refresh token keys.
+ */
+function getTokenConfig() {
+    return tokensConfig;
+}
+
+/**
+ * Converts an ArrayBuffer or Uint8Array to a hexadecimal string.
+ * @param buffer The ArrayBuffer or Uint8Array to convert.
+ * @returns The hexadecimal string.
+ */
+function ab2hex(buffer) {
+    return Array.from(new Uint8Array(buffer))
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+/**
+ * Converts a hexadecimal string to a Uint8Array.
+ * @param hex The hexadecimal string to convert.
+ * @returns The Uint8Array.
+ * @throws {TypeError} If the input is not a string.
+ * @throws {Error} If the hexadecimal string format is invalid or has an odd length.
+ */
+function hex2ab(hex) {
+    if (typeof hex !== "string") {
+        throw new TypeError("Input must be a string.");
+    }
+    if (hex.length === 0) {
+        return new Uint8Array();
+    }
+    if (!/^[0-9a-fA-F]*$/.test(hex) || hex.length % 2 !== 0) {
+        throw new Error("Invalid hexadecimal string format or odd length.");
+    }
+    const array = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        array[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return array;
+}
+/**
+ * Derives an encryption key from a secret key.
+ * @param secretKey The secret key in plain text.
+ * @returns A promise that resolves with the derived CryptoKey.
+ * @throws {Error} If the secretKey is null or empty.
+ */
+async function importKey(secretKey) {
+    if (!secretKey) {
+        throw new Error("Secret key cannot be null or empty.");
+    }
+    const keyMaterial = new TextEncoder().encode(secretKey);
+    const digest = await crypto.subtle.digest("SHA-256", keyMaterial);
+    return crypto.subtle.importKey("raw", digest, { name: "AES-CBC", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+/**
+ * Encrypts a value with the provided secret key.
+ * @param value The value to encrypt.
+ * @param secretKey The secret key for encryption.
+ * @returns A promise that resolves with the IV (hex) + ciphertext (hex) string.
+ * @throws {Error} If the secretKey is null or empty (via importKey).
+ */
+async function encrypt(value, secretKey) {
+    const key = await importKey(secretKey);
+    const iv = crypto.getRandomValues(new Uint8Array(16));
+    const encodedValue = new TextEncoder().encode(value);
+    const ciphertext = await crypto.subtle.encrypt({ name: "AES-CBC", iv: iv }, key, encodedValue);
+    return ab2hex(iv) + ab2hex(new Uint8Array(ciphertext));
+}
+/**
+ * Decrypts an encrypted value.
+ * @param encryptedValue The encrypted string (IV_hex + ciphertext_hex).
+ * @param secretKey The secret key for decryption.
+ * @returns A promise that resolves with the decrypted value.
+ * @throws {Error} If encryptedValue is null or empty, too short,
+ * or if the IV/ciphertext have incorrect lengths after conversion.
+ * @throws {Error} If the secretKey is null or empty (via importKey).
+ * @throws {TypeError} If hex2ab receives an invalid input type.
+ */
+async function decrypt(encryptedValue, secretKey) {
+    if (!encryptedValue) {
+        throw new Error("Encrypted value cannot be null or empty.");
+    }
+    // For AES-CBC, the IV is ALWAYS 16 bytes.
+    // 16 bytes * 2 hex characters/byte = 32 hex characters for the IV.
+    if (encryptedValue.length < 32) {
+        throw new Error("Encrypted value is too short. Expected at least 32 hexadecimal characters for the IV.");
+    }
+    const key = await importKey(secretKey);
+    const ivHex = encryptedValue.substring(0, 32);
+    const ciphertextHex = encryptedValue.substring(32);
+    const iv = hex2ab(ivHex);
+    const ciphertext = hex2ab(ciphertextHex);
+    if (iv.byteLength !== 16) {
+        throw new Error(`Converted IV has incorrect length: ${iv.byteLength} bytes. Expected 16 bytes.`);
+    }
+    if (ciphertext.byteLength === 0) {
+        throw new Error("Ciphertext is empty. No data to decrypt.");
+    }
+    const decryptedBuffer = await crypto.subtle.decrypt({ name: "AES-CBC", iv: iv }, key, ciphertext);
+    return new TextDecoder().decode(decryptedBuffer);
+}
+
+/**
+ * Encrypts and stores an item in local or session storage.
+ * Assumes the `window` environment is available.
+ * @param key The key under which to store the value.
+ * @param value The value to encrypt and store.
+ * @param secretKey The secret key for encryption.
+ * @param location Determines where the item is stored: 'local' for localStorage, 'session' for sessionStorage.
+ * @returns A promise that resolves when the item is stored. Throws an error if it fails.
+ */
+async function storeEncryptedItem(key, value, secretKey, location) {
+    if (typeof window === "undefined") {
+        throw new Error("Cannot access storage: window is not defined.");
+    }
+    const storage = location === "local" ? window.localStorage : window.sessionStorage;
+    const encryptedValue = await encrypt(value, secretKey);
+    storage.setItem(key, encryptedValue);
+}
+/**
+ * Retrieves and decrypts a value from local or session storage.
+ * Assumes the `window` environment is available.
+ * @param key The key of the item to retrieve.
+ * @param secretKey The secret key for decryption.
+ * @param location Specifies where to search for the item: 'local' for localStorage, 'session' for sessionStorage, or 'any' to check both (session first).
+ * @returns A promise that resolves with the decrypted value or null if not found or decryption fails.
+ */
+async function getDecryptedItem(key, secretKey, location) {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    let encryptedData = null;
+    if (location === "session" || location === "any") {
+        encryptedData = window.sessionStorage.getItem(key);
+    }
+    if (!encryptedData && (location === "local" || location === "any")) {
+        encryptedData = window.localStorage.getItem(key);
+    }
+    if (!encryptedData) {
+        return null;
+    }
+    try {
+        return await decrypt(encryptedData, secretKey);
+    }
+    catch (error) {
+        return null;
+    }
+}
+
 /**
  * Enum defining available screen sizes.
  */
@@ -538,35 +709,6 @@ function inferErrorType(error) {
     return 'error';
 }
 
-let tokensConfig = Object.freeze({
-    ACCESS_TOKEN: "access_token",
-    REFRESH_TOKEN: "refresh_token",
-});
-/**
- * Configures the global keys for access and refresh tokens.
- * Once set, they cannot be modified.
- *
- * @param {TokenKeyConfig} config - An object containing the token keys.
- * @param {string} config.accessTokenKey - The name of the key for the access token.
- * @param {string} config.refreshTokenKey - The name of the key for the refresh token.
- *
- * @returns {void} Does not return anything, but freezes the token configuration object.
- */
-function configTokenKeys(config) {
-    tokensConfig = Object.freeze({
-        ACCESS_TOKEN: config.accessTokenKey,
-        REFRESH_TOKEN: config.refreshTokenKey,
-    });
-}
-/**
- * Retrieves the current token configuration.
- *
- * @returns {TokensConfig} The configuration of the access and refresh token keys.
- */
-function getTokenConfig() {
-    return tokensConfig;
-}
-
 let endpointsConfig = {
     LOGIN: "/login",
     REFRESH: "/refresh",
@@ -602,322 +744,20 @@ function getEndpointsConfig() {
     return endpointsConfig;
 }
 
+let appKey = null;
 /**
- * AxiosService class encapsulates the Axios configuration and logic.
- * It manages request and response interceptors and provides methods for making HTTP requests.
+ * Sets the main application encryption key.
+ * This key is expected to be used for encryption purposes within the application.
+ *
+ * @param {AppKeyConfig} config - An object containing the application encryption key.
+ * @param {string} config.key - The new application encryption key.
+ *
+ * @returns {void} Does not return anything, but updates the application key.
+ * @throws {Error} If the provided key is null, undefined, or an empty string.
  */
-class AxiosService {
-    instance;
-    cancelTokenSource;
-    activeRequests = 0;
-    refreshTokenInProgress = false;
-    refreshTokenUrl;
-    /**
-     * Initializes the AxiosService instance by creating an Axios instance with default configuration
-     * and setting up request and response interceptors.
-     */
-    constructor(url, headers = {}) {
-        this.cancelTokenSource = axios.CancelToken.source();
-        this.instance = axios.create({
-            baseURL: url ?? '',
-            timeout: 300000,
-            headers: {
-                'Accept': 'application/json',
-                ...headers,
-            },
-            withCredentials: false,
-        });
-        const endpointsConfig = getEndpointsConfig();
-        this.refreshTokenUrl = endpointsConfig.REFRESH;
-        this.initializeInterceptors();
-    }
-    /**
-     * Initializes request and response interceptors for the Axios instance.
-     */
-    initializeInterceptors() {
-        const { ACCESS_TOKEN, REFRESH_TOKEN } = getTokenConfig();
-        this.instance.interceptors.request.use((config) => {
-            const token = typeof window !== 'undefined' ? localStorage.getItem(ACCESS_TOKEN) : null;
-            if (token && config.headers) {
-                config.headers.Authorization = `Bearer ${token}`;
-            }
-            config.cancelToken = this.cancelTokenSource.token;
-            this.activeRequests++;
-            return config;
-        }, (error) => {
-            handleError(error, false);
-            this.activeRequests++;
-            return Promise.reject(error);
-        });
-        this.instance.interceptors.response.use((response) => {
-            this.activeRequests--;
-            return response;
-        }, async (error) => {
-            this.activeRequests--;
-            // Check for unauthorized access (401)
-            if (axios.isAxiosError(error) && error.response?.status === 401 && !this.refreshTokenInProgress) {
-                const refreshToken = localStorage.getItem(REFRESH_TOKEN);
-                if (refreshToken) {
-                    this.refreshTokenInProgress = true;
-                    try {
-                        // Attempt to refresh the token
-                        const refreshResponse = await axios.post(this.refreshTokenUrl, { refreshToken });
-                        const { token: newAccessToken } = refreshResponse.data;
-                        if (newAccessToken) {
-                            // Save the new access token
-                            localStorage.setItem(ACCESS_TOKEN, newAccessToken);
-                            // Retry the original request with the new token
-                            if (error.config && error.config.headers) {
-                                error.config.headers['Authorization'] = `Bearer ${newAccessToken}`;
-                            }
-                            this.refreshTokenInProgress = false;
-                            if (error.config) {
-                                return this.instance(error.config);
-                            }
-                        }
-                    }
-                    catch (refreshError) {
-                        handleError(refreshError, false);
-                        this.refreshTokenInProgress = false;
-                        localStorage.removeItem(ACCESS_TOKEN);
-                        localStorage.removeItem(REFRESH_TOKEN);
-                    }
-                }
-            }
-            handleError(error, false);
-            return Promise.reject(error);
-        });
-    }
-    /**
-     * Returns the number of active requests.
-     */
-    getActiveRequests() {
-        return this.activeRequests;
-    }
-    /**
-     * 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];
-    }
-}
-
-let axiosInstance;
-/**
- * Configures the global Axios instance with a base URL.
- *
- * @param {AxiosConfig} config - An object containing the base URL for the Axios instance.
- * @param {string} config.baseURL - The base URL for the Axios instance.
- *
- * @returns {void}
- */
-const configAxios = (config) => {
-    axiosInstance = new AxiosService(config.baseURL);
-};
-/**
- * Retrieves the configured Axios instance.
- *
- * @returns {AxiosService} The configured Axios instance.
- * @throws Will throw an error if the Axios instance is not configured.
- */
-const getAxiosInstance = () => {
-    if (!axiosInstance) {
-        throw new Error("Axios instance not configured. Call configAxios first.");
-    }
-    return axiosInstance.getAxiosInstance();
-};
-/**
- * Creates a new AxiosService instance with custom headers.
- *
- * @param {CustomAxiosConfig} config - An object containing the base URL and optional custom headers.
- * @param {string} config.baseURL - The base URL for the Axios instance.
- * @param {Record<string, string>} [config.headers] - Custom headers to set (optional).
- *
- * @returns {AxiosService} The new AxiosService instance.
- */
-const createCustomAxiosInstance = (config) => {
-    return new AxiosService(config.baseURL, config.headers).getAxiosInstance();
-};
-
-/**
- * Converts an ArrayBuffer or Uint8Array to a hexadecimal string.
- * @param buffer The ArrayBuffer or Uint8Array to convert.
- * @returns The hexadecimal string.
- */
-function ab2hex(buffer) {
-    return Array.from(new Uint8Array(buffer))
-        .map((byte) => byte.toString(16).padStart(2, "0"))
-        .join("");
-}
-/**
- * Converts a hexadecimal string to a Uint8Array.
- * @param hex The hexadecimal string to convert.
- * @returns The Uint8Array.
- * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the hexadecimal string format is invalid or has an odd length.
- */
-function hex2ab(hex) {
-    if (typeof hex !== "string") {
-        throw new TypeError("Input must be a string.");
-    }
-    if (hex.length === 0) {
-        return new Uint8Array();
-    }
-    if (!/^[0-9a-fA-F]*$/.test(hex) || hex.length % 2 !== 0) {
-        throw new Error("Invalid hexadecimal string format or odd length.");
-    }
-    const array = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-        array[i / 2] = parseInt(hex.substring(i, i + 2), 16);
-    }
-    return array;
-}
-/**
- * Derives an encryption key from a secret key.
- * @param secretKey The secret key in plain text.
- * @returns A promise that resolves with the derived CryptoKey.
- * @throws {Error} If the secretKey is null or empty.
- */
-async function importKey(secretKey) {
-    if (!secretKey) {
-        throw new Error("Secret key cannot be null or empty.");
-    }
-    const keyMaterial = new TextEncoder().encode(secretKey);
-    const digest = await crypto.subtle.digest("SHA-256", keyMaterial);
-    return crypto.subtle.importKey("raw", digest, { name: "AES-CBC", length: 256 }, false, ["encrypt", "decrypt"]);
-}
-/**
- * Encrypts a value with the provided secret key.
- * @param value The value to encrypt.
- * @param secretKey The secret key for encryption.
- * @returns A promise that resolves with the IV (hex) + ciphertext (hex) string.
- * @throws {Error} If the secretKey is null or empty (via importKey).
- */
-async function encrypt(value, secretKey) {
-    const key = await importKey(secretKey);
-    const iv = crypto.getRandomValues(new Uint8Array(16));
-    const encodedValue = new TextEncoder().encode(value);
-    const ciphertext = await crypto.subtle.encrypt({ name: "AES-CBC", iv: iv }, key, encodedValue);
-    return ab2hex(iv) + ab2hex(new Uint8Array(ciphertext));
-}
-/**
- * Decrypts an encrypted value.
- * @param encryptedValue The encrypted string (IV_hex + ciphertext_hex).
- * @param secretKey The secret key for decryption.
- * @returns A promise that resolves with the decrypted value.
- * @throws {Error} If encryptedValue is null or empty, too short,
- * or if the IV/ciphertext have incorrect lengths after conversion.
- * @throws {Error} If the secretKey is null or empty (via importKey).
- * @throws {TypeError} If hex2ab receives an invalid input type.
- */
-async function decrypt(encryptedValue, secretKey) {
-    if (!encryptedValue) {
-        throw new Error("Encrypted value cannot be null or empty.");
-    }
-    // For AES-CBC, the IV is ALWAYS 16 bytes.
-    // 16 bytes * 2 hex characters/byte = 32 hex characters for the IV.
-    if (encryptedValue.length < 32) {
-        throw new Error("Encrypted value is too short. Expected at least 32 hexadecimal characters for the IV.");
-    }
-    const key = await importKey(secretKey);
-    const ivHex = encryptedValue.substring(0, 32);
-    const ciphertextHex = encryptedValue.substring(32);
-    const iv = hex2ab(ivHex);
-    const ciphertext = hex2ab(ciphertextHex);
-    if (iv.byteLength !== 16) {
-        throw new Error(`Converted IV has incorrect length: ${iv.byteLength} bytes. Expected 16 bytes.`);
-    }
-    if (ciphertext.byteLength === 0) {
-        throw new Error("Ciphertext is empty. No data to decrypt.");
-    }
-    const decryptedBuffer = await crypto.subtle.decrypt({ name: "AES-CBC", iv: iv }, key, ciphertext);
-    return new TextDecoder().decode(decryptedBuffer);
-}
-
-/**
- * Encrypts and stores an item in local or session storage.
- * Assumes the `window` environment is available.
- * @param key The key under which to store the value.
- * @param value The value to encrypt and store.
- * @param secretKey The secret key for encryption.
- * @param location Determines where the item is stored: 'local' for localStorage, 'session' for sessionStorage.
- * @returns A promise that resolves when the item is stored. Throws an error if it fails.
- */
-async function storeEncryptedItem(key, value, secretKey, location) {
-    if (typeof window === "undefined") {
-        throw new Error("Cannot access storage: window is not defined.");
-    }
-    const storage = location === "local" ? window.localStorage : window.sessionStorage;
-    const encryptedValue = await encrypt(value, secretKey);
-    storage.setItem(key, encryptedValue);
-}
-/**
- * Retrieves and decrypts a value from local or session storage.
- * Assumes the `window` environment is available.
- * @param key The key of the item to retrieve.
- * @param secretKey The secret key for decryption.
- * @param location Specifies where to search for the item: 'local' for localStorage, 'session' for sessionStorage, or 'any' to check both (session first).
- * @returns A promise that resolves with the decrypted value or null if not found or decryption fails.
- */
-async function getDecryptedItem(key, secretKey, location) {
-    if (typeof window === "undefined") {
-        return null;
-    }
-    let encryptedData = null;
-    if (location === "session" || location === "any") {
-        encryptedData = window.sessionStorage.getItem(key);
-    }
-    if (!encryptedData && (location === "local" || location === "any")) {
-        encryptedData = window.localStorage.getItem(key);
-    }
-    if (!encryptedData) {
-        return null;
-    }
-    try {
-        return await decrypt(encryptedData, secretKey);
-    }
-    catch (error) {
-        return null;
-    }
-}
-
-let appKey = null;
-/**
- * Sets the main application encryption key.
- * This key is expected to be used for encryption purposes within the application.
- *
- * @param {AppKeyConfig} config - An object containing the application encryption key.
- * @param {string} config.key - The new application encryption key.
- *
- * @returns {void} Does not return anything, but updates the application key.
- * @throws {Error} If the provided key is null, undefined, or an empty string.
- */
-function configAppKey(config) {
-    if (!config || !config.appKey || config.appKey.trim() === "") {
-        throw new Error("The application encryption key cannot be null or empty.");
+function configAppKey(config) {
+    if (!config || !config.appKey || config.appKey.trim() === "") {
+        throw new Error("The application encryption key cannot be null or empty.");
     }
     appKey = config.appKey;
 }
@@ -1042,39 +882,712 @@ async function getSessionConfig() {
 }
 
 /**
- * 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.
+ * Clears all stored authentication data (access and refresh tokens)
+ * from either sessionStorage, localStorage, or both based on the provided location preference.
+ *
+ * @param {LocationPreference} location - The storage preference ('local' for localStorage, 'session' for sessionStorage, 'any' for both).
+ * @returns {Promise<void>} A promise that resolves when all relevant storage items are removed.
  */
-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);
-}
+const cleanCredentials = async (location) => {
+    const tokensConfig = getTokenConfig();
+    Object.keys(tokensConfig).forEach((key) => {
+        const itemKey = tokensConfig[key];
+        if (location === "local" || location === "any") {
+            localStorage.removeItem(itemKey);
+        }
+        if (location === "session" || location === "any") {
+            sessionStorage.removeItem(itemKey);
+        }
+    });
+};
 /**
- * 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.
+ * Retrieves the authentication token (access token) from storage, decrypting it
+ * using the provided secret key and based on the specified session preference.
+ *
+ * @param {string} secretKey - The secret key used for decryption.
+ * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
+ * @returns {Promise<string | null>} A promise that resolves with the decrypted access token, or null if not found.
  */
-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;' });
+const getAuthToken = async (secretKey, location) => {
+    const tokensConfig = getTokenConfig();
+    return await getDecryptedItem(tokensConfig.ACCESS_TOKEN, secretKey, location);
+};
+/**
+ * Retrieves the authentication refresh token from storage, decrypting it
+ * using the provided secret key and based on the specified session preference.
+ *
+ * @param {string} secretKey - The secret key used for decryption.
+ * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
+ * @returns {Promise<string | null>} A promise that resolves with the decrypted refresh token, or null if not found.
+ */
+const getAuthRefreshToken = async (secretKey, location) => {
+    const tokensConfig = getTokenConfig();
+    return await getDecryptedItem(tokensConfig.REFRESH_TOKEN, secretKey, location);
+};
+/**
+ * Stores the authentication token (access token) in storage after encrypting it,
+ * based on the specified session preference.
+ *
+ * @param {string} token - The access token to store.
+ * @param {string} secretKey - The secret key used for encryption.
+ * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
+ * @returns {Promise<void>} A promise that resolves when the token is successfully stored.
+ */
+const storeAuthToken = async (token, secretKey, location) => {
+    const tokensConfig = getTokenConfig();
+    await storeEncryptedItem(tokensConfig.ACCESS_TOKEN, token, secretKey, location);
+};
+/**
+ * Stores the authentication refresh token in storage after encrypting it,
+ * based on the specified session preference.
+ *
+ * @param {string} token - The refresh token to store.
+ * @param {string} secretKey - The secret key used for encryption.
+ * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
+ * @returns {Promise<void>} A promise that resolves when the token is successfully stored.
+ */
+const storeAuthRefreshToken = async (token, secretKey, location) => {
+    const tokensConfig = getTokenConfig();
+    await storeEncryptedItem(tokensConfig.REFRESH_TOKEN, token, secretKey, location);
+};
+/**
+ * Verifies the validity and expiration of the current authentication token.
+ * If the token is missing, invalid, or expired, appropriate errors are thrown and credentials are cleaned.
+ *
+ * @returns {Promise<boolean>} True if the token is valid and unexpired.
+ * @throws {Error} "TOKEN_MISSING" if no token is found, "TOKEN_EXPIRED" if the token has expired,
+ * "TOKEN_INVALID" if the token format is invalid.
+ */
+const verifyAuth = async () => {
+    const sessionPersistence = 'any';
+    const handleAuthError = async (message, shouldClean = true) => {
+        handleError(message, false);
+        if (shouldClean) {
+            await cleanCredentials(sessionPersistence);
+        }
+        return false;
+    };
+    try {
+        const token = await getAuthToken(getAppKey(), sessionPersistence);
+        if (!token) {
+            return await handleAuthError("TOKEN_MISSING: No valid token found");
+        }
+        let decoded;
+        try {
+            decoded = jwtDecode(token);
+        }
+        catch (decodeError) {
+            return await handleAuthError("TOKEN_INVALID: Invalid token format");
+        }
+        const currentTime = Date.now() / 1000;
+        if (typeof decoded.exp !== "number") {
+            return await handleAuthError("TOKEN_INVALID: Invalid expiration format");
+        }
+        if (decoded.exp <= currentTime) {
+            return await handleAuthError("TOKEN_EXPIRED: Token is expired");
+        }
+        return true;
+    }
+    catch (error) {
+        return await handleAuthError("AUTH_ERROR: An unexpected error occurred", true);
+    }
+};
+
+class AxiosService {
+    instance;
+    cancelTokenSource;
+    activeRequests = 0;
+    refreshTokenUrl;
+    refreshAuth;
+    isRefreshing = false;
+    failedQueue = [];
+    constructor(options, refreshAuth) {
+        this.cancelTokenSource = axios.CancelToken.source();
+        this.refreshAuth = refreshAuth;
+        const endpointsConfig = getEndpointsConfig();
+        this.refreshTokenUrl = endpointsConfig.REFRESH;
+        this.instance = axios.create({
+            baseURL: options.baseURL ?? "",
+            timeout: options.timeout ?? 30000,
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                ...options.headers,
+            },
+            withCredentials: options.withCredentials ?? false,
+        });
+        this.initializeInterceptors();
+    }
+    processQueue(error, token = null) {
+        this.failedQueue.forEach((prom) => {
+            if (error) {
+                prom.reject(error);
+            }
+            else if (token) {
+                prom.resolve(token);
+            }
+        });
+        this.failedQueue = [];
+    }
+    setAuthHeader(config, token) {
+        if (config.headers) {
+            config.headers.Authorization = `Bearer ${token}`;
+        }
+    }
+    initializeInterceptors() {
+        this.instance.interceptors.request.use(async (config) => {
+            const token = await getAuthToken(getAppKey(), "any");
+            if (token) {
+                this.setAuthHeader(config, token);
+            }
+            config.cancelToken = this.cancelTokenSource.token;
+            this.activeRequests++;
+            return config;
+        }, (error) => {
+            handleError(error, false);
+            return Promise.reject(error);
+        });
+        this.instance.interceptors.response.use((response) => {
+            this.activeRequests--;
+            return response;
+        }, async (error) => {
+            this.activeRequests--;
+            const originalRequest = error.config;
+            const isAuthError = axios.isAxiosError(error) && error.response?.status === 401;
+            const isRefreshCall = originalRequest?.url === this.refreshTokenUrl;
+            const isRetry = originalRequest?._retry === true;
+            if (!isAuthError || isRefreshCall || isRetry) {
+                handleError(error, false);
+                return Promise.reject(error);
+            }
+            if (!originalRequest) {
+                handleError(error, false);
+                return Promise.reject(error);
+            }
+            if (this.isRefreshing) {
+                return new Promise((resolve, reject) => {
+                    this.failedQueue.push({ resolve, reject });
+                })
+                    .then((newToken) => {
+                    this.setAuthHeader(originalRequest, newToken);
+                    return this.instance(originalRequest);
+                })
+                    .catch((err) => {
+                    return Promise.reject(err);
+                });
+            }
+            this.isRefreshing = true;
+            originalRequest._retry = true;
+            try {
+                await this.refreshAuth();
+                const newToken = await getAuthToken(getAppKey(), "any");
+                if (newToken) {
+                    this.processQueue(null, newToken);
+                    this.setAuthHeader(originalRequest, newToken);
+                }
+                else {
+                    const refreshError = new Error("New token not found after refresh.");
+                    this.processQueue(refreshError, null);
+                    throw refreshError;
+                }
+                this.isRefreshing = false;
+                return this.instance(originalRequest);
+            }
+            catch (refreshError) {
+                this.processQueue(refreshError, null);
+                this.isRefreshing = false;
+                handleError(refreshError, false);
+                return Promise.reject(error);
+            }
+        });
+    }
+    getActiveRequests() {
+        return this.activeRequests;
+    }
+    getAxiosInstance() {
+        return this.instance;
+    }
+    cancelAllRequests() {
+        this.cancelTokenSource.cancel("Operation canceled by the user.");
+        this.cancelTokenSource = axios.CancelToken.source();
+    }
+    setHeader(key, value) {
+        this.instance.defaults.headers.common[key] = value;
+    }
+    removeHeader(key) {
+        delete this.instance.defaults.headers.common[key];
+    }
+}
+
+/**
+ * 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 }
+
+/**
+ * @typedef {object} AuthHook
+ * @property {function(): Promise<number | null>} getTokenExpiry - Retrieves the expiration time of the current token in milliseconds.
+ * @property {function(): Promise<void>} cleanCredentials - Clears authentication credentials from storage.
+ * @property {(params?: AuthParams) => Promise<void>} logout - Logs out the user, clears credentials, and reloads the page.
+ * @property {(params: AuthParams, persistence: SessionPreference, tokenPaths?: AuthTokenPaths) => Promise<AuthResponse>} login - Logs in the user and stores tokens.
+ * @property {(tokenPaths?: AuthTokenPaths) => Promise<AuthResponse>} refresh - Refreshes authentication tokens.
+ * @property {function(): Promise<boolean>} verifyAuth - Verifies the validity and expiration of the current authentication token.
+ * @property {(preference: SessionPreference) => void} setSessionPersistencePreference - Sets the user's preferred storage for authentication data.
+ * @property {function(): SessionPreference} getSessionPersistence - Retrieves the user's current preferred storage for authentication data.
+ */
+/**
+ * Custom hook for authentication logic, including login, logout, token management, and session preference.
+ *
+ * @param {string} secretKey - The secret key used for token encryption/decryption.
+ * @returns {AuthHook} An object containing authentication functions.
+ */
+function useAuth(secretKey = getAppKey()) {
+    const axiosInstance = getAxiosInstance();
+    const endpoints = getEndpointsConfig();
+    /**
+     * Logs out the user by making a POST request to the logout endpoint,
+     * cleaning all stored credentials, and reloading the page.
+     * The session persistence preference is NOT reset here; it persists across logouts.
+     *
+     * @param {AuthParams} [params={}] - Optional parameters to send with the logout request.
+     * @returns {Promise<void>}
+     */
+    const logout = async (params = {}) => {
+        try {
+            await axiosInstance.post(endpoints.LOGOUT, params);
+        }
+        catch (error) {
+            handleError(error, false);
+        }
+        finally {
+            await cleanCredentials(await getSessionPersistence());
+            window.location.reload();
+        }
+    };
+    /**
+     * Authenticates the user by making a POST request to the login endpoint,
+     * stores the received access and refresh tokens, and sets the session persistence preference.
+     *
+     * @param {AuthParams} params - The authentication parameters (e.g., username, password).
+     * @param {SessionPreference} persistence - The storage preference: 'local' for localStorage, 'session' for sessionStorage.
+     * @param {AuthTokenPaths} [tokenPaths] - Configuración opcional para las rutas (en notación de punto) donde se encuentran los tokens en la respuesta de la API.
+     * @returns {Promise<AuthResponse>} La respuesta de autenticación que contiene los tokens e información del usuario.
+     * @throws {Error} Si la solicitud de login falla, o si los tokens de acceso/refresco no se encuentran o no son válidos en la respuesta.
+     */
+    const login = async (params, persistence, tokenPaths) => {
+        try {
+            const { data } = await axiosInstance.post(endpoints.LOGIN, params);
+            const accessTokenPath = tokenPaths?.accessTokenPath || "access_token";
+            const refreshTokenPath = tokenPaths?.refreshTokenPath || "refresh_token";
+            const accessTokenPathArray = accessTokenPath.split(".");
+            const refreshTokenPathArray = refreshTokenPath.split(".");
+            if (!data) {
+                throw new Error("LOGIN_ERROR: No data received from login endpoint.");
+            }
+            const accessToken = safeGet(data, accessTokenPathArray);
+            const refreshToken = safeGet(data, refreshTokenPathArray);
+            if (!accessToken || typeof accessToken !== "string") {
+                throw new Error(`LOGIN_ERROR: Access token not found or invalid at path '${accessTokenPath}' in response.`);
+            }
+            if (!refreshToken || typeof refreshToken !== "string") {
+                throw new Error(`LOGIN_ERROR: Refresh token not found or invalid at path '${refreshTokenPath}' in response.`);
+            }
+            configSession({
+                persistencePreference: persistence,
+            });
+            await storeAuthToken(accessToken, secretKey, persistence);
+            await storeAuthRefreshToken(refreshToken, secretKey, persistence);
+            return data;
+        }
+        catch (error) {
+            handleError(error, false);
+            throw error;
+        }
+    };
+    /**
+     * Refreshes the authentication tokens using the stored refresh token.
+     * This function can also accept optional token paths if the refresh endpoint
+     * returns tokens with a different structure than the default login.
+     * If no refresh token is found, it throws an error and initiates a logout.
+     *
+     * @param {AuthTokenPaths} [tokenPaths] - Configuración opcional para las rutas (en notación de punto) de los tokens de acceso y refresco en la respuesta del endpoint de refresco.
+     * @returns {Promise<AuthResponse>} The new authentication response with refreshed tokens.
+     * @throws {Error} If the refresh token is missing or the refresh request fails.
+     */
+    const refresh = async (tokenPaths) => {
+        try {
+            const refreshTokenFromStorage = await getAuthRefreshToken(secretKey, 'any');
+            if (!refreshTokenFromStorage) {
+                throw new Error("TOKEN_MISSING: No refresh token found in storage.");
+            }
+            const { data } = await axiosInstance.post(endpoints.REFRESH, { refresh_token: refreshTokenFromStorage });
+            const accessTokenPath = tokenPaths?.accessTokenPath || "access_token";
+            const refreshTokenPath = tokenPaths?.refreshTokenPath || "refresh_token";
+            const accessTokenPathArray = accessTokenPath.split(".");
+            const refreshTokenPathArray = refreshTokenPath.split(".");
+            if (!data) {
+                throw new Error("REFRESH_ERROR: No data received from refresh endpoint.");
+            }
+            const accessTokenAfterRefresh = safeGet(data, accessTokenPathArray);
+            const refreshTokenAfterRefresh = safeGet(data, refreshTokenPathArray);
+            if (!accessTokenAfterRefresh ||
+                typeof accessTokenAfterRefresh !== "string") {
+                throw new Error(`REFRESH_ERROR: Access token not found or invalid at path '${accessTokenPath}' in refresh response.`);
+            }
+            if (!refreshTokenAfterRefresh ||
+                typeof refreshTokenAfterRefresh !== "string") {
+                throw new Error(`REFRESH_ERROR: Refresh token not found or invalid at path '${refreshTokenPath}' in refresh response.`);
+            }
+            await storeAuthToken(accessTokenAfterRefresh, secretKey, await getSessionPersistence());
+            await storeAuthRefreshToken(refreshTokenAfterRefresh, secretKey, await getSessionPersistence());
+            return data;
+        }
+        catch (error) {
+            handleError(error, false);
+            await logout();
+            throw error;
+        }
+    };
+    return {
+        logout,
+        login,
+        refresh,
+    };
+}
+
+let axiosInstance;
+const auth = useAuth();
+const refreshAndForget = async () => {
+    await auth.refresh();
+};
+const configAxios = (config) => {
+    axiosInstance = new AxiosService({
+        baseURL: config.baseURL,
+    }, refreshAndForget);
+};
+const getAxiosInstance = () => {
+    if (!axiosInstance) {
+        throw new Error("Axios instance not configured. Call configAxios first.");
+    }
+    return axiosInstance.getAxiosInstance();
+};
+const createCustomAxiosInstance = (config) => {
+    return new AxiosService({
+        baseURL: config.baseURL,
+        headers: config.headers,
+    }, refreshAndForget).getAxiosInstance();
+};
+
+/**
+ * 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);
 }
@@ -1879,417 +2392,136 @@ function debounceLeadingTrailing(func, wait) {
     };
 }
 /**
- * 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.
+ * 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 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] };
+function debounce(func, wait) {
+    let timeoutReject = null;
+    return function (...args) {
+        if (timeoutReject) {
+            timeoutReject(new Error('replaced'));
+            timeoutReject = null;
         }
-    }
-    return differences;
+        const { start } = useTimeoutFn(() => {
+            func.apply(this, args);
+        }, wait);
+        timeoutReject = () => { };
+        start();
+    };
 }
 /**
- * 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.
+ * 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 filterObjectByKeys(obj, keys) {
-    const filteredObject = {};
-    for (const key of keys) {
-        if (key in obj) {
-            filteredObject[key] = obj[key];
+function throttle(func, limit) {
+    let lastCall = 0;
+    return function (...args) {
+        const now = Date.now();
+        if (now - lastCall >= limit) {
+            lastCall = now;
+            func.apply(this, args);
         }
-    }
-    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.
+ * 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 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] });
+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);
         }
-    }
-    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);
+        else {
+            obj[key] = value;
+        }
+    });
+    return 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.
+ * Reads a file as text.
+ * @param {File} file The file to read.
+ * @returns {Promise<string>} A promise that resolves with the file content.
  */
-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;
-    }, {});
+function readFileAsText(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsText(file);
+    });
 }
-// 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.
+ * 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 getObjectKeys(obj) {
-    return Object.keys(obj);
+function readFileAsDataURL(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
 }
-// 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.
+ * 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 hasNestedProperties(obj) {
-    return Object.values(obj).some(value => typeof value === 'object' && value !== null);
+function stringToBlob(content, type = 'text/plain') {
+    return new Blob([content], { type });
 }
-// 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.
+ * 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 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;
+function bufferToBlob(buffer, type = 'application/octet-stream') {
+    return new Blob([buffer], { type });
 }
-// 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.
+ * 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 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;
+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;
 }
-// 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.
@@ -2703,118 +2935,6 @@ function isValidHexNumber(hex) {
 // console.log(isValidHexNumber('1A3F')); // true
 // console.log(isValidHexNumber('GHIJ')); // false
 
-/**
- * Clears all stored authentication data (access and refresh tokens)
- * from either sessionStorage, localStorage, or both based on the provided location preference.
- *
- * @param {LocationPreference} location - The storage preference ('local' for localStorage, 'session' for sessionStorage, 'any' for both).
- * @returns {Promise<void>} A promise that resolves when all relevant storage items are removed.
- */
-const cleanCredentials = async (location) => {
-    const tokensConfig = getTokenConfig();
-    Object.keys(tokensConfig).forEach((key) => {
-        const itemKey = tokensConfig[key];
-        if (location === "local" || location === "any") {
-            localStorage.removeItem(itemKey);
-        }
-        if (location === "session" || location === "any") {
-            sessionStorage.removeItem(itemKey);
-        }
-    });
-};
-/**
- * Retrieves the authentication token (access token) from storage, decrypting it
- * using the provided secret key and based on the specified session preference.
- *
- * @param {string} secretKey - The secret key used for decryption.
- * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
- * @returns {Promise<string | null>} A promise that resolves with the decrypted access token, or null if not found.
- */
-const getAuthToken = async (secretKey, location) => {
-    const tokensConfig = getTokenConfig();
-    return await getDecryptedItem(tokensConfig.ACCESS_TOKEN, secretKey, location);
-};
-/**
- * Retrieves the authentication refresh token from storage, decrypting it
- * using the provided secret key and based on the specified session preference.
- *
- * @param {string} secretKey - The secret key used for decryption.
- * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
- * @returns {Promise<string | null>} A promise that resolves with the decrypted refresh token, or null if not found.
- */
-const getAuthRefreshToken = async (secretKey, location) => {
-    const tokensConfig = getTokenConfig();
-    return await getDecryptedItem(tokensConfig.REFRESH_TOKEN, secretKey, location);
-};
-/**
- * Stores the authentication token (access token) in storage after encrypting it,
- * based on the specified session preference.
- *
- * @param {string} token - The access token to store.
- * @param {string} secretKey - The secret key used for encryption.
- * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
- * @returns {Promise<void>} A promise that resolves when the token is successfully stored.
- */
-const storeAuthToken = async (token, secretKey, location) => {
-    const tokensConfig = getTokenConfig();
-    await storeEncryptedItem(tokensConfig.ACCESS_TOKEN, token, secretKey, location);
-};
-/**
- * Stores the authentication refresh token in storage after encrypting it,
- * based on the specified session preference.
- *
- * @param {string} token - The refresh token to store.
- * @param {string} secretKey - The secret key used for encryption.
- * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
- * @returns {Promise<void>} A promise that resolves when the token is successfully stored.
- */
-const storeAuthRefreshToken = async (token, secretKey, location) => {
-    const tokensConfig = getTokenConfig();
-    await storeEncryptedItem(tokensConfig.REFRESH_TOKEN, token, secretKey, location);
-};
-/**
- * Verifies the validity and expiration of the current authentication token.
- * If the token is missing, invalid, or expired, appropriate errors are thrown and credentials are cleaned.
- *
- * @returns {Promise<boolean>} True if the token is valid and unexpired.
- * @throws {Error} "TOKEN_MISSING" if no token is found, "TOKEN_EXPIRED" if the token has expired,
- * "TOKEN_INVALID" if the token format is invalid.
- */
-const verifyAuth = async () => {
-    const sessionPersistence = 'any';
-    const handleAuthError = async (message, shouldClean = true) => {
-        handleError(message, false);
-        if (shouldClean) {
-            await cleanCredentials(sessionPersistence);
-        }
-        return false;
-    };
-    try {
-        const token = await getAuthToken(getAppKey(), sessionPersistence);
-        if (!token) {
-            return await handleAuthError("TOKEN_MISSING: No valid token found");
-        }
-        let decoded;
-        try {
-            decoded = jwtDecode(token);
-        }
-        catch (decodeError) {
-            return await handleAuthError("TOKEN_INVALID: Invalid token format");
-        }
-        const currentTime = Date.now() / 1000;
-        if (typeof decoded.exp !== "number") {
-            return await handleAuthError("TOKEN_INVALID: Invalid expiration format");
-        }
-        if (decoded.exp <= currentTime) {
-            return await handleAuthError("TOKEN_EXPIRED: Token is expired");
-        }
-        return true;
-    }
-    catch (error) {
-        return await handleAuthError("AUTH_ERROR: An unexpected error occurred", true);
-    }
-};
-
 class RestStd {
     static resource;
     static isFormData = false;
@@ -3366,137 +3486,6 @@ function useSorter(items, criteriaList, selectedCriteria) {
     }).value;
 }
 
-/**
- * @typedef {object} AuthHook
- * @property {function(): Promise<number | null>} getTokenExpiry - Retrieves the expiration time of the current token in milliseconds.
- * @property {function(): Promise<void>} cleanCredentials - Clears authentication credentials from storage.
- * @property {(params?: AuthParams) => Promise<void>} logout - Logs out the user, clears credentials, and reloads the page.
- * @property {(params: AuthParams, persistence: SessionPreference, tokenPaths?: AuthTokenPaths) => Promise<AuthResponse>} login - Logs in the user and stores tokens.
- * @property {(tokenPaths?: AuthTokenPaths) => Promise<AuthResponse>} refresh - Refreshes authentication tokens.
- * @property {function(): Promise<boolean>} verifyAuth - Verifies the validity and expiration of the current authentication token.
- * @property {(preference: SessionPreference) => void} setSessionPersistencePreference - Sets the user's preferred storage for authentication data.
- * @property {function(): SessionPreference} getSessionPersistence - Retrieves the user's current preferred storage for authentication data.
- */
-/**
- * Custom hook for authentication logic, including login, logout, token management, and session preference.
- *
- * @param {string} secretKey - The secret key used for token encryption/decryption.
- * @returns {AuthHook} An object containing authentication functions.
- */
-function useAuth(secretKey = getAppKey()) {
-    const axiosInstance = getAxiosInstance();
-    const endpoints = getEndpointsConfig();
-    /**
-     * Logs out the user by making a POST request to the logout endpoint,
-     * cleaning all stored credentials, and reloading the page.
-     * The session persistence preference is NOT reset here; it persists across logouts.
-     *
-     * @param {AuthParams} [params={}] - Optional parameters to send with the logout request.
-     * @returns {Promise<void>}
-     */
-    const logout = async (params = {}) => {
-        try {
-            await axiosInstance.post(endpoints.LOGOUT, params);
-        }
-        catch (error) {
-            handleError(error, false);
-        }
-        finally {
-            await cleanCredentials(await getSessionPersistence());
-            window.location.reload();
-        }
-    };
-    /**
-     * Authenticates the user by making a POST request to the login endpoint,
-     * stores the received access and refresh tokens, and sets the session persistence preference.
-     *
-     * @param {AuthParams} params - The authentication parameters (e.g., username, password).
-     * @param {SessionPreference} persistence - The storage preference: 'local' for localStorage, 'session' for sessionStorage.
-     * @param {AuthTokenPaths} [tokenPaths] - Configuración opcional para las rutas (en notación de punto) donde se encuentran los tokens en la respuesta de la API.
-     * @returns {Promise<AuthResponse>} La respuesta de autenticación que contiene los tokens e información del usuario.
-     * @throws {Error} Si la solicitud de login falla, o si los tokens de acceso/refresco no se encuentran o no son válidos en la respuesta.
-     */
-    const login = async (params, persistence, tokenPaths) => {
-        try {
-            const { data } = await axiosInstance.post(endpoints.LOGIN, params);
-            const accessTokenPath = tokenPaths?.accessTokenPath || "access_token";
-            const refreshTokenPath = tokenPaths?.refreshTokenPath || "refresh_token";
-            const accessTokenPathArray = accessTokenPath.split(".");
-            const refreshTokenPathArray = refreshTokenPath.split(".");
-            if (!data) {
-                throw new Error("LOGIN_ERROR: No data received from login endpoint.");
-            }
-            const accessToken = safeGet(data, accessTokenPathArray);
-            const refreshToken = safeGet(data, refreshTokenPathArray);
-            if (!accessToken || typeof accessToken !== "string") {
-                throw new Error(`LOGIN_ERROR: Access token not found or invalid at path '${accessTokenPath}' in response.`);
-            }
-            if (!refreshToken || typeof refreshToken !== "string") {
-                throw new Error(`LOGIN_ERROR: Refresh token not found or invalid at path '${refreshTokenPath}' in response.`);
-            }
-            configSession({
-                persistencePreference: persistence,
-            });
-            await storeAuthToken(accessToken, secretKey, persistence);
-            await storeAuthRefreshToken(refreshToken, secretKey, persistence);
-            return data;
-        }
-        catch (error) {
-            handleError(error, false);
-            throw error;
-        }
-    };
-    /**
-     * Refreshes the authentication tokens using the stored refresh token.
-     * This function can also accept optional token paths if the refresh endpoint
-     * returns tokens with a different structure than the default login.
-     * If no refresh token is found, it throws an error and initiates a logout.
-     *
-     * @param {AuthTokenPaths} [tokenPaths] - Configuración opcional para las rutas (en notación de punto) de los tokens de acceso y refresco en la respuesta del endpoint de refresco.
-     * @returns {Promise<AuthResponse>} The new authentication response with refreshed tokens.
-     * @throws {Error} If the refresh token is missing or the refresh request fails.
-     */
-    const refresh = async (tokenPaths) => {
-        try {
-            const refreshTokenFromStorage = await getAuthRefreshToken(secretKey, await getSessionPersistence());
-            if (!refreshTokenFromStorage) {
-                throw new Error("TOKEN_MISSING: No refresh token found in storage.");
-            }
-            const { data } = await axiosInstance.post(endpoints.REFRESH, { refresh_token: refreshTokenFromStorage });
-            const accessTokenPath = tokenPaths?.accessTokenPath || "access_token";
-            const refreshTokenPath = tokenPaths?.refreshTokenPath || "refresh_token";
-            const accessTokenPathArray = accessTokenPath.split(".");
-            const refreshTokenPathArray = refreshTokenPath.split(".");
-            if (!data) {
-                throw new Error("REFRESH_ERROR: No data received from refresh endpoint.");
-            }
-            const accessTokenAfterRefresh = safeGet(data, accessTokenPathArray);
-            const refreshTokenAfterRefresh = safeGet(data, refreshTokenPathArray);
-            if (!accessTokenAfterRefresh ||
-                typeof accessTokenAfterRefresh !== "string") {
-                throw new Error(`REFRESH_ERROR: Access token not found or invalid at path '${accessTokenPath}' in refresh response.`);
-            }
-            if (!refreshTokenAfterRefresh ||
-                typeof refreshTokenAfterRefresh !== "string") {
-                throw new Error(`REFRESH_ERROR: Refresh token not found or invalid at path '${refreshTokenPath}' in refresh response.`);
-            }
-            await storeAuthToken(accessTokenAfterRefresh, secretKey, await getSessionPersistence());
-            await storeAuthRefreshToken(refreshTokenAfterRefresh, secretKey, await getSessionPersistence());
-            return data;
-        }
-        catch (error) {
-            handleError(error, false);
-            await logout();
-            throw error;
-        }
-    };
-    return {
-        logout,
-        login,
-        refresh,
-    };
-}
-
 /**
  * The Vue plugin for @arex95/vue-core.
  * Configures the core functionalities for authentication and API communication.