@arex95/vue-core 1.1.35 → 1.1.36

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,68 +709,288 @@ 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.
+ * Clears all stored authentication data (access and refresh tokens)
+ * from either sessionStorage, localStorage, or both based on the provided location preference.
  *
- * @returns {void} Does not return anything, but freezes the token configuration object.
+ * @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 configTokenKeys(config) {
-    tokensConfig = Object.freeze({
-        ACCESS_TOKEN: config.accessTokenKey,
-        REFRESH_TOKEN: config.refreshTokenKey,
+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 current token configuration.
+ * Retrieves the authentication token (access token) from storage, decrypting it
+ * using the provided secret key and based on the specified session preference.
  *
- * @returns {TokensConfig} The configuration of the access and refresh token keys.
+ * @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 getTokenConfig() {
-    return tokensConfig;
-}
-
-let endpointsConfig = {
-    LOGIN: "/login",
-    REFRESH: "/refresh",
-    LOGOUT: "/logout",
+const getAuthToken = async (secretKey, location) => {
+    const tokensConfig = getTokenConfig();
+    return await getDecryptedItem(tokensConfig.ACCESS_TOKEN, secretKey, location);
 };
 /**
- * Configures authentication endpoint URLs globally.
- * This function freezes the object to prevent further modifications.
- *
- * @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.
+ * 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.
- */
-function getEndpointsConfig() {
-    return endpointsConfig;
+ * @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);
+    }
+};
+
+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.");
+    }
+    appKey = config.appKey;
+}
+/**
+ * Retrieves the current application encryption key.
+ * Throws an error if the application key has not been configured.
+ *
+ * @returns {string} The configured application encryption key.
+ * @throws {Error} If the application encryption key has not been set.
+ */
+function getAppKey() {
+    if (appKey === null) {
+        throw new Error("The application encryption key has not been configured. Please call 'configAppKey()' before attempting to access it.");
+    }
+    return appKey;
+}
+
+const SESSION_KEY = "session_config_";
+const internalSessionState = {
+    sessionId: v4(),
+    persistencePreference: "session",
+};
+let _sessionConfig = Object.freeze({
+    SESSION_ID: internalSessionState.sessionId,
+    PERSISTENCE: internalSessionState.persistencePreference,
+});
+/**
+ * Updates the immutable `_sessionConfig` object with the current state of `internalSessionState`
+ * and freezes it.
+ */
+function updateSessionConfig() {
+    _sessionConfig = Object.freeze({
+        SESSION_ID: internalSessionState.sessionId,
+        PERSISTENCE: internalSessionState.persistencePreference,
+    });
+}
+/**
+ * Saves the current session configuration to local or session storage.
+ * @returns {Promise<void>} A promise that resolves when the session configuration has been saved.
+ */
+async function saveSessionConfig() {
+    const location = internalSessionState.persistencePreference;
+    try {
+        await storeEncryptedItem(SESSION_KEY, JSON.stringify(_sessionConfig), getAppKey(), location);
+    }
+    catch (error) {
+        console.error("Error saving session configuration to storage:", error);
+    }
+}
+/**
+ * Attempts to load the configuration from storage.
+ * If it fails or is not found, `internalSessionState` will retain its current values (initial or last configured).
+ * Then, it updates `_sessionConfig`.
+ *
+ * @returns {Promise<void>} A promise that resolves when the state has been loaded and updated.
+ */
+async function loadSessionConfig() {
+    const location = internalSessionState.persistencePreference;
+    try {
+        const storedConfig = await getDecryptedItem(SESSION_KEY, getAppKey(), location);
+        if (storedConfig) {
+            const parsedConfig = JSON.parse(storedConfig);
+            internalSessionState.sessionId = parsedConfig.SESSION_ID;
+            internalSessionState.persistencePreference = parsedConfig.PERSISTENCE;
+            updateSessionConfig();
+        }
+    }
+    catch (error) {
+        console.warn(`Error loading or parsing from storage`, error);
+    }
+}
+/**
+ * Configures the session identifier and/or data persistence preference
+ * for the active browser session.
+ *
+ * This function is asynchronous because it will always attempt to load the current configuration
+ * before applying changes and then saving them.
+ *
+ * @param {SessionConfigObject} config - An object containing the unique session identifier and/or
+ * the persistence preference.
+ * @returns {Promise<void>} A promise that resolves when the session has been configured and saved.
+ */
+async function configSession(config) {
+    if (config.sessionId) {
+        internalSessionState.sessionId = config.sessionId;
+    }
+    if (config.persistencePreference) {
+        internalSessionState.persistencePreference = config.persistencePreference;
+    }
+    updateSessionConfig();
+    await saveSessionConfig();
+}
+/**
+ * Retrieves the current session identifier.
+ * Always attempts to load the configuration from storage. If it fails, it uses the internal state.
+ *
+ * @returns {Promise<string>} A promise that resolves with the unique session identifier.
+ */
+async function getSessionId() {
+    await loadSessionConfig();
+    return _sessionConfig.SESSION_ID;
+}
+/**
+ * Retrieves the current data persistence preference.
+ * Always attempts to load the configuration from storage. If it fails, it uses the internal state.
+ *
+ * @returns {Promise<SessionPreference>} A promise that resolves with the configured persistence preference ('local' or 'session').
+ */
+async function getSessionPersistence() {
+    await loadSessionConfig();
+    return _sessionConfig.PERSISTENCE;
+}
+/**
+ * Retrieves the complete session configuration.
+ * Always attempts to load the configuration from storage. If it fails, it uses the internal state.
+ *
+ * @returns {Promise<SessionConfig>} A promise that resolves with the session configuration object.
+ */
+async function getSessionConfig() {
+    await loadSessionConfig();
+    return _sessionConfig;
+}
+
+let endpointsConfig = {
+    LOGIN: "/login",
+    REFRESH: "/refresh",
+    LOGOUT: "/logout",
+};
+/**
+ * Configures authentication endpoint URLs globally.
+ * This function freezes the object to prevent further modifications.
+ *
+ * @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.
+ *
+ * @returns {void} Does not return anything but freezes the endpoint configuration object.
+ */
+function configEndpoints(config) {
+    endpointsConfig = Object.freeze({
+        LOGIN: config.loginEndpoint,
+        REFRESH: config.refreshEndpoint,
+        LOGOUT: config.logoutEndpoint,
+    });
+}
+/**
+ * Retrieves the configured authentication endpoint URLs.
+ *
+ * @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.
+ */
+function getEndpointsConfig() {
+    return endpointsConfig;
 }
 
 /**
@@ -635,9 +1026,8 @@ class AxiosService {
      * 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;
+        this.instance.interceptors.request.use(async (config) => {
+            const token = await getAuthToken(getAppKey(), 'any');
             if (token && config.headers) {
                 config.headers.Authorization = `Bearer ${token}`;
             }
@@ -654,19 +1044,15 @@ class AxiosService {
             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);
+                const refreshToken = await getAuthRefreshToken(getAppKey(), "any");
                 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
+                            storeAuthToken(newAccessToken, getAppKey(), await getSessionPersistence());
                             if (error.config && error.config.headers) {
                                 error.config.headers['Authorization'] = `Bearer ${newAccessToken}`;
                             }
@@ -679,8 +1065,7 @@ class AxiosService {
                     catch (refreshError) {
                         handleError(refreshError, false);
                         this.refreshTokenInProgress = false;
-                        localStorage.removeItem(ACCESS_TOKEN);
-                        localStorage.removeItem(REFRESH_TOKEN);
+                        cleanCredentials('any');
                     }
                 }
             }
@@ -692,354 +1077,75 @@ class AxiosService {
      * 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.");
-    }
-    appKey = config.appKey;
-}
-/**
- * Retrieves the current application encryption key.
- * Throws an error if the application key has not been configured.
- *
- * @returns {string} The configured application encryption key.
- * @throws {Error} If the application encryption key has not been set.
- */
-function getAppKey() {
-    if (appKey === null) {
-        throw new Error("The application encryption key has not been configured. Please call 'configAppKey()' before attempting to access it.");
+        return this.activeRequests;
     }
-    return appKey;
-}
-
-const SESSION_KEY = "session_config_";
-const internalSessionState = {
-    sessionId: v4(),
-    persistencePreference: "session",
-};
-let _sessionConfig = Object.freeze({
-    SESSION_ID: internalSessionState.sessionId,
-    PERSISTENCE: internalSessionState.persistencePreference,
-});
-/**
- * Updates the immutable `_sessionConfig` object with the current state of `internalSessionState`
- * and freezes it.
- */
-function updateSessionConfig() {
-    _sessionConfig = Object.freeze({
-        SESSION_ID: internalSessionState.sessionId,
-        PERSISTENCE: internalSessionState.persistencePreference,
-    });
-}
-/**
- * Saves the current session configuration to local or session storage.
- * @returns {Promise<void>} A promise that resolves when the session configuration has been saved.
- */
-async function saveSessionConfig() {
-    const location = internalSessionState.persistencePreference;
-    try {
-        await storeEncryptedItem(SESSION_KEY, JSON.stringify(_sessionConfig), getAppKey(), location);
+    /**
+     * Returns the Axios instance with the configured settings and interceptors.
+     * @returns {AxiosInstance} The configured Axios instance.
+     */
+    getAxiosInstance() {
+        return this.instance;
     }
-    catch (error) {
-        console.error("Error saving session configuration to storage:", error);
+    /**
+     * Cancels all ongoing requests.
+     */
+    cancelAllRequests() {
+        this.cancelTokenSource.cancel('Operation canceled by the user.');
+        this.cancelTokenSource = axios.CancelToken.source();
     }
-}
-/**
- * Attempts to load the configuration from storage.
- * If it fails or is not found, `internalSessionState` will retain its current values (initial or last configured).
- * Then, it updates `_sessionConfig`.
- *
- * @returns {Promise<void>} A promise that resolves when the state has been loaded and updated.
- */
-async function loadSessionConfig() {
-    const location = internalSessionState.persistencePreference;
-    try {
-        const storedConfig = await getDecryptedItem(SESSION_KEY, getAppKey(), location);
-        if (storedConfig) {
-            const parsedConfig = JSON.parse(storedConfig);
-            internalSessionState.sessionId = parsedConfig.SESSION_ID;
-            internalSessionState.persistencePreference = parsedConfig.PERSISTENCE;
-            updateSessionConfig();
-        }
+    /**
+     * 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;
     }
-    catch (error) {
-        console.warn(`Error loading or parsing from storage`, error);
+    /**
+     * 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 session identifier and/or data persistence preference
- * for the active browser session.
+ * Configures the global Axios instance with a base URL.
  *
- * This function is asynchronous because it will always attempt to load the current configuration
- * before applying changes and then saving them.
+ * @param {AxiosConfig} config - An object containing the base URL for the Axios instance.
+ * @param {string} config.baseURL - The base URL for the Axios instance.
  *
- * @param {SessionConfigObject} config - An object containing the unique session identifier and/or
- * the persistence preference.
- * @returns {Promise<void>} A promise that resolves when the session has been configured and saved.
+ * @returns {void}
  */
-async function configSession(config) {
-    if (config.sessionId) {
-        internalSessionState.sessionId = config.sessionId;
-    }
-    if (config.persistencePreference) {
-        internalSessionState.persistencePreference = config.persistencePreference;
-    }
-    updateSessionConfig();
-    await saveSessionConfig();
-}
+const configAxios = (config) => {
+    axiosInstance = new AxiosService(config.baseURL);
+};
 /**
- * Retrieves the current session identifier.
- * Always attempts to load the configuration from storage. If it fails, it uses the internal state.
+ * Retrieves the configured Axios instance.
  *
- * @returns {Promise<string>} A promise that resolves with the unique session identifier.
+ * @returns {AxiosService} The configured Axios instance.
+ * @throws Will throw an error if the Axios instance is not configured.
  */
-async function getSessionId() {
-    await loadSessionConfig();
-    return _sessionConfig.SESSION_ID;
-}
+const getAxiosInstance = () => {
+    if (!axiosInstance) {
+        throw new Error("Axios instance not configured. Call configAxios first.");
+    }
+    return axiosInstance.getAxiosInstance();
+};
 /**
- * Retrieves the current data persistence preference.
- * Always attempts to load the configuration from storage. If it fails, it uses the internal state.
+ * Creates a new AxiosService instance with custom headers.
  *
- * @returns {Promise<SessionPreference>} A promise that resolves with the configured persistence preference ('local' or 'session').
- */
-async function getSessionPersistence() {
-    await loadSessionConfig();
-    return _sessionConfig.PERSISTENCE;
-}
-/**
- * Retrieves the complete session configuration.
- * Always attempts to load the configuration from storage. If it fails, it uses the internal state.
+ * @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 {Promise<SessionConfig>} A promise that resolves with the session configuration object.
+ * @returns {AxiosService} The new AxiosService instance.
  */
-async function getSessionConfig() {
-    await loadSessionConfig();
-    return _sessionConfig;
-}
+const createCustomAxiosInstance = (config) => {
+    return new AxiosService(config.baseURL, config.headers).getAxiosInstance();
+};
 
 /**
  * Creates and downloads a file from Blob data.
@@ -2703,118 +2809,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arex95/vue-core",
-  "version": "1.1.35",
+  "version": "1.1.36",
   "description": "Opinionated Vue Core",
   "main": "dist/index.js",
   "module": "dist/index.mjs",