@arex95/vue-core 1.1.36 → 1.1.37

package/dist/index.mjs

@@ -709,117 +709,40 @@ function inferErrorType(error) {
     return 'error';
 }
 
-/**
- * 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);
+let endpointsConfig = {
+    LOGIN: "/login",
+    REFRESH: "/refresh",
+    LOGOUT: "/logout",
 };
 /**
- * Stores the authentication token (access token) in storage after encrypting it,
- * based on the specified session preference.
+ * Configures authentication endpoint URLs globally.
+ * This function freezes the object to prevent further modifications.
  *
- * @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 {EndpointConfig} config - An object containing the authentication endpoint URLs.
+ * @param {string} config.loginEndpoint - URL of the login endpoint.
+ * @param {string} config.refreshEndpoint - URL of the refresh token endpoint.
+ * @param {string} config.logoutEndpoint - URL of the logout endpoint.
  *
- * @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.
+ * @returns {void} Does not return anything but freezes the endpoint configuration object.
  */
-const storeAuthRefreshToken = async (token, secretKey, location) => {
-    const tokensConfig = getTokenConfig();
-    await storeEncryptedItem(tokensConfig.REFRESH_TOKEN, token, secretKey, location);
-};
+function configEndpoints(config) {
+    endpointsConfig = Object.freeze({
+        LOGIN: config.loginEndpoint,
+        REFRESH: config.refreshEndpoint,
+        LOGOUT: config.logoutEndpoint,
+    });
+}
 /**
- * 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.
+ * Retrieves the configured authentication endpoint URLs.
  *
- * @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.
+ * @returns {EndpointsConfig} An object containing the configured authentication endpoints.
+ * @property {string} LOGIN - URL of the login endpoint.
+ * @property {string} REFRESH - URL of the refresh token endpoint.
+ * @property {string} LOGOUT - URL of the logout endpoint.
  */
-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);
-    }
-};
+function getEndpointsConfig() {
+    return endpointsConfig;
+}
 
 let appKey = null;
 /**
@@ -958,193 +881,677 @@ async function getSessionConfig() {
     return _sessionConfig;
 }
 
-let endpointsConfig = {
-    LOGIN: "/login",
-    REFRESH: "/refresh",
-    LOGOUT: "/logout",
+/**
+ * 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);
+        }
+    });
 };
 /**
- * Configures authentication endpoint URLs globally.
- * This function freezes the object to prevent further modifications.
+ * Retrieves the authentication token (access token) from storage, decrypting it
+ * using the provided secret key and based on the specified session preference.
  *
- * @param {EndpointConfig} config - An object containing the authentication endpoint URLs.
- * @param {string} config.loginEndpoint - URL of the login endpoint.
- * @param {string} config.refreshEndpoint - URL of the refresh token endpoint.
- * @param {string} config.logoutEndpoint - URL of the logout endpoint.
+ * @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.
  *
- * @returns {void} Does not return anything but freezes the endpoint configuration object.
+ * @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.
  */
-function configEndpoints(config) {
-    endpointsConfig = Object.freeze({
-        LOGIN: config.loginEndpoint,
-        REFRESH: config.refreshEndpoint,
-        LOGOUT: config.logoutEndpoint,
-    });
-}
+const getAuthRefreshToken = async (secretKey, location) => {
+    const tokensConfig = getTokenConfig();
+    return await getDecryptedItem(tokensConfig.REFRESH_TOKEN, secretKey, location);
+};
 /**
- * Retrieves the configured authentication endpoint URLs.
+ * Stores the authentication token (access token) in storage after encrypting it,
+ * based on the specified session preference.
  *
- * @returns {EndpointsConfig} An object containing the configured authentication endpoints.
- * @property {string} LOGIN - URL of the login endpoint.
- * @property {string} REFRESH - URL of the refresh token endpoint.
- * @property {string} LOGOUT - URL of the logout endpoint.
+ * @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.
  */
-function getEndpointsConfig() {
-    return endpointsConfig;
-}
-
+const storeAuthToken = async (token, secretKey, location) => {
+    const tokensConfig = getTokenConfig();
+    await storeEncryptedItem(tokensConfig.ACCESS_TOKEN, token, secretKey, location);
+};
 /**
- * AxiosService class encapsulates the Axios configuration and logic.
- * It manages request and response interceptors and provides methods for making HTTP requests.
+ * 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.
  */
-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() {
-        this.instance.interceptors.request.use(async (config) => {
-            const token = await getAuthToken(getAppKey(), 'any');
-            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--;
-            if (axios.isAxiosError(error) && error.response?.status === 401 && !this.refreshTokenInProgress) {
-                const refreshToken = await getAuthRefreshToken(getAppKey(), "any");
-                if (refreshToken) {
-                    this.refreshTokenInProgress = true;
-                    try {
-                        const refreshResponse = await axios.post(this.refreshTokenUrl, { refreshToken });
-                        const { token: newAccessToken } = refreshResponse.data;
-                        if (newAccessToken) {
-                            storeAuthToken(newAccessToken, getAppKey(), await getSessionPersistence());
-                            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;
-                        cleanCredentials('any');
-                    }
-                }
-            }
-            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.
-     */
+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;
     }
-    /**
-     * Cancels all ongoing requests.
-     */
     cancelAllRequests() {
-        this.cancelTokenSource.cancel('Operation canceled by the user.');
+        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];
     }
 }
 
+/**
+ * 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;
-/**
- * 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 auth = useAuth();
+const refreshAndForget = async () => {
+    await auth.refresh();
+};
 const configAxios = (config) => {
-    axiosInstance = new AxiosService(config.baseURL);
+    axiosInstance = new AxiosService({
+        baseURL: config.baseURL,
+    }, refreshAndForget);
 };
-/**
- * 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();
+    return new AxiosService({
+        baseURL: config.baseURL,
+        headers: config.headers,
+    }, refreshAndForget).getAxiosInstance();
 };
 
 /**
@@ -2060,342 +2467,61 @@ function readFileAsText(file) {
  * @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);
+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.
+ * 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.
  */
-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;
-};
+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);
+}
 /**
- * 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 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 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 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.
@@ -3360,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.