@arex95/vue-core 1.1.43 → 3.0.0

package/README.md

@@ -1,64 +1,97 @@
 # @arex95/vue-core
 
-Opinionated Vue Core
+A comprehensive Vue.js core library designed to streamline the development of Vue applications. It provides a set of composables, utilities, and services for handling common tasks such as API communication, authentication, and data management.
 
-## Descripción
+## Features
 
-Conjunto de composables y utilidades para Vue.js, diseñado para facilitar el desarrollo de aplicaciones Vue. Proporciona herramientas para manejar peticiones HTTP con Axios. Además, incluye wrappers para TanStack Vue Query, que simplifican la gestión de estados de datos asíncronos, y una implementación estándar para interactuar con APIs RESTful, facilitando la creación, lectura, actualización y eliminación de recursos.
+- **RESTful Standard**: A standardized RESTful class (`RestStd`) that you can extend directly from your models for clean, semantic API calls (e.g., `User.getOne()`).
+- **Fetching Agnostic**: Works with any fetching system (Axios, ofetch, fetch API, or custom fetchers).
+- **Flexible Authentication**: JWT-based authentication system that works with any fetcher (not tied to Axios).
+- **Enhanced Error Handling**: Custom error classes (`NetworkError`, `AuthError`, `ValidationError`, etc.) with structured error information.
+- **Retry Logic**: Built-in retry mechanism with exponential backoff for failed requests.
+- **Secure Storage**: Support for localStorage, sessionStorage, and cookies with encryption and security options (Secure, SameSite).
+- **SSR/SSG Support**: Full support for server-side rendering with automatic cookie fallback.
+- **Type Safety**: Improved generic types for better TypeScript inference and autocompletion.
+- **Utility Functions**: A rich collection of utilities for dates, strings, validations, encryption, and more.
 
-## Arquitectura Modular Basada en Servicios
-
-Esta arquitectura está diseñada para seguir principios sólidos de `separación de responsabilidades` y `modularidad`, implementando una estructura en la que `los servicios gestionan la lógica de negocio` relacionada con la interacción con APIs, mientras que `las vistas se encargan exclusivamente de la presentación`.
-
-## Concepto General de la Arquitectura
-
-1. **Separación de Responsabilidades**:
-   En este diseño, las vistas no tienen que ocuparse de la lógica de obtención o mutación de datos. Esta responsabilidad está delegada a los **servicios**, que gestionan todo el proceso de interactuar con las APIs, realizar solicitudes HTTP y manipular los modelos. Las vistas simplemente se encargan de la **presentación de los datos** y de gestionar las interacciones del usuario, como capturar eventos o mostrar resultados.
-
-    - `Vistas`: Su tarea principal es mostrar los datos que obtienen de los servicios. Se centran en la parte visual y en las interacciones de usuario.
-    - `Servicios`: Son responsables de gestionar cómo y desde dónde se obtienen los datos. Aquí es donde se realiza toda la lógica de acceso a las APIs, manejo de respuestas y errores, y mutación de modelos.
-
-   Este enfoque reduce la complejidad de las vistas, las cuales permanecen limpias y fáciles de entender. Cualquier cambio en la forma de hacer las solicitudes (como cambiar la estructura de la API o el cliente HTTP) no requiere modificaciones en las vistas, lo que mejora la mantenibilidad.
-
-2. **Desacoplamiento de la Lógica de la API**:
-
-   Los servicios encapsulan completamente la lógica de interacción con las APIs. Las vistas no necesitan saber nada sobre cómo se hace la solicitud a la API o cómo se gestionan las respuestas. Este desacoplamiento permite que las vistas sean **más limpias** y **menos propensas a errores**, ya que no necesitan manejar la lógica de negocio ni los detalles de las peticiones HTTP. Si en el futuro la forma de interactuar con la API cambia (por ejemplo, si se cambia el cliente HTTP o se agrega un middleware), solo será necesario modificar los servicios, no las vistas.
-
-   Este enfoque también permite que los servicios sean **reutilizables** en diferentes partes de la aplicación. Por ejemplo, si varias vistas necesitan autenticar al usuario, todas pueden utilizar el servicio `AuthService`, sin necesidad de duplicar la lógica de autenticación.
-
-3. **Reusabilidad y Modularidad**:
-
-   Al centralizar la lógica de negocio en servicios, estos pueden ser fácilmente **reutilizados** en diferentes vistas y componentes de la aplicación. Cada servicio está diseñado para encargarse de una única funcionalidad o módulo del sistema, como la autenticación, gestión de productos, gestión de categorías, etc. Este enfoque modular hace que la aplicación sea **más fácil de escalar**.
-
-   Además, la modularidad permite que cada servicio evolucione y cambie de forma independiente sin afectar a otros módulos o partes de la aplicación. Si un nuevo servicio debe ser agregado, como uno para manejar un módulo adicional (por ejemplo, pagos o notificaciones), se puede hacer sin interrumpir el flujo de trabajo de los demás servicios.
-
-4. **Mejora en la Escalabilidad**:
-
-   Esta arquitectura facilita la escalabilidad, ya que cualquier servicio puede ser **ampliado o modificado de forma independiente** sin necesidad de reestructurar la aplicación completa. Por ejemplo, si el servicio de productos necesita cambios en la lógica de consulta, esto no afectará al servicio de autenticación o a las vistas que consumen esos servicios. Esta flexibilidad es crucial cuando el sistema crece y se añaden nuevas funcionalidades.
-
-5. **Facilidad de Pruebas Unitarias**:
-
-   Al estar los servicios desacoplados de las vistas, es mucho más fácil realizar **pruebas unitarias** de cada servicio de manera aislada. Las vistas no necesitan ser simuladas ni involucradas en las pruebas de negocio, lo que facilita la escritura de pruebas unitarias puras para la lógica de las APIs y el manejo de los datos.
-
-   Por ejemplo, el servicio `AuthService` puede probarse por separado para verificar si maneja correctamente el proceso de inicio de sesión o si responde correctamente a los errores de autenticación, sin necesidad de preocuparse por el diseño de las vistas o la interacción con el usuario.
-
-6. **Mantenimiento Sostenible**:
-
-   En un proyecto grande o en evolución, esta arquitectura facilita el mantenimiento del código. Si hay un error relacionado con la autenticación, se puede solucionar directamente en el servicio `AuthService`, sin tener que revisar todas las vistas que consumen este servicio. Esto hace que el código sea más fácil de entender y más fácil de depurar.
-
-   Además, si es necesario cambiar la lógica de la API (como cambiar el formato de las respuestas), solo es necesario modificar los servicios afectados. Las vistas seguirán funcionando de la misma manera, ya que están desacopladas de esta lógica.
-
-
-## Estructura del Proyecto
-
-- **src/composables**: Contiene composables reutilizables para Axios, filtros, paginadores y ordenadores.
-- **src/config**: Configuraciones para Axios.
-- **src/constants**: Constantes utilizadas en el proyecto, como enumeraciones de breakpoints, excepciones, tipos de archivos, etc.
-- **src/rest**: Implementación estándar de una interfaz REST para operaciones CRUD. Proporciona una forma sencilla y estandarizada de interactuar con APIs RESTful, facilitando la creación de servicios que pueden realizar operaciones como crear, leer, actualizar y eliminar recursos.
-- **src/types**: Tipos TypeScript utilizados en el proyecto.
-- **src/utils**: Utilidades varias, como funciones para manejar fechas, validaciones, manipulación de strings, etc.
-
-## Instalación
+## Installation
 
 ```sh
-npm install @arex95/vue-core
+npm install @arex95/vue-core
+```
+
+## Quick Start
+
+To get started, you need to configure the library in your main `main.ts` file.
+
+```typescript
+import { createApp } from 'vue';
+import App from './App.vue';
+import { ArexVueCore } from '@arex95/vue-core';
+
+const app = createApp(App);
+
+app.use(ArexVueCore, {
+  appKey: 'your-secret-key',
+  endpoints: {
+    login: '/api/login',
+    refresh: '/api/refresh',
+    logout: '/api/logout',
+  },
+  tokenKeys: {
+    accessToken: 'ACCESS_TOKEN',
+    refreshToken: 'REFRESH_TOKEN',
+  },
+  tokenPaths: {
+    accessToken: 'data.access_token',
+    refreshToken: 'data.refresh_token',
+  },
+  refreshTokenPaths: {
+    accessToken: 'data.access_token',
+    refreshToken: 'data.refresh_token',
+  },
+  axios: {
+    baseURL: 'https://api.example.com',
+  },
+});
+
+app.mount('#app');
+```
+
+**Create a model:**
+
+```typescript
+import { RestStd } from '@arex95/vue-core';
+
+export interface UserData {
+  id: number;
+  name: string;
+  email: string;
+}
+
+export class User extends RestStd {
+  static override resource = 'users';
+  // fetchFn is optional if you configured Axios with configAxios()
+}
+
+// Use directly in components
+const { data: users } = useQuery({
+  queryKey: ['users'],
+  queryFn: () => User.getAll<UserData[]>(),
+});
+```
+
+For more detailed usage examples, please refer to the [documentation](./docs/getting-started.md) and [EXAMPLES.md](./EXAMPLES.md) file.
+
+## Project Structure
+
+- **`src/composables`**: Reusable Vue composables for various functionalities.
+- **`src/config`**: Global configuration for Axios, API endpoints, and tokens.
+- **`src/enums`**: Enums for constants used throughout the library.
+- **`src/fetchers`**: Optional helpers for creating fetchers (Axios, ofetch).
+- **`src/rest`**: A standardized RESTful class (`RestStd`) for CRUD operations.
+- **`src/services`**: Services for authentication and token management.
+- **`src/types`**: TypeScript type definitions.
+- **`src/utils`**: A collection of utility functions.
+
+For a more in-depth explanation of the project's architecture, please see the [ARCHITECTURE.md](./ARCHITECTURE.md) file.

package/dist/composables/auth/useAuth.d.ts

@@ -1,11 +1,25 @@
-import { AuthResponse, AuthTokenPaths, LocationPreference } from "@/types";
+import { AuthResponse, AuthTokenPaths, LocationPreference, Fetcher } from "@/types";
 /**
  * Custom hook for authentication logic, including login, logout, token management, and session preference.
+ * Accepts an optional fetcher function. If not provided, uses the default configured fetcher or falls back to Axios.
  *
- * @param {string} secretKey - The secret key used for token encryption/decryption.
- * @returns {AuthHook} An object containing authentication functions.
+ * @param {Fetcher} [fetcher] - Optional fetcher function to use for auth requests. If not provided, uses the default configured fetcher.
+ * @returns {{
+ *   logout: (params?: Record<string, unknown>) => Promise<void>,
+ *   login: (params: Record<string, unknown>, persistence: LocationPreference, tokenPaths?: AuthTokenPaths) => Promise<AuthResponse>
+ * }} An object containing authentication functions.
+ *
+ * @example
+ * ```typescript
+ * // Using default fetcher (Axios)
+ * const auth = useAuth();
+ *
+ * // Using custom fetcher
+ * const customFetcher = createOfetchFetcher();
+ * const auth = useAuth(customFetcher);
+ * ```
  */
-export declare function useAuth(): {
-    logout: (params?: any) => Promise<void>;
-    login: (params: any | undefined, persistence: LocationPreference, tokenPaths?: AuthTokenPaths) => Promise<AuthResponse>;
+export declare function useAuth(fetcher?: Fetcher): {
+    logout: (params?: Record<string, unknown>) => Promise<void>;
+    login: (params: Record<string, unknown> | undefined, persistence: LocationPreference, tokenPaths?: AuthTokenPaths) => Promise<AuthResponse>;
 };

package/dist/composables/axios/axiosFetch.d.ts

@@ -1,10 +1,12 @@
 import { AxiosInstance, AxiosRequestConfig } from 'axios';
 /**
- * Custom composable function for making API requests with Axios.
+ * A composable function that executes an Axios request and returns the response data.
+ * It simplifies making API calls by wrapping the Axios request in a reusable function.
  *
- * @template T The expected return type of the API request.
- * @param {AxiosInstance} axios - The Axios instance for making HTTP requests.
- * @param {AxiosRequestConfig} axiosRequest - Configuration for the Axios request.
- * @returns {Promise<T>} A promise with the result of the API request.
+ * @template T The expected type of the response data.
+ * @param {AxiosInstance} axios - The Axios instance to use for making the request.
+ * @param {AxiosRequestConfig} axiosRequest - The configuration for the Axios request (e.g., URL, method, headers).
+ * @returns {Promise<T>} A promise that resolves with the data from the Axios response.
+ * @throws {Error} Throws an error if the Axios request fails.
  */
 export declare function axiosFetch<T>(axios: AxiosInstance, axiosRequest: AxiosRequestConfig): Promise<T>;

package/dist/composables/axios/index.d.ts

@@ -1,3 +1,2 @@
 export * from './axiosFetch';
 export * from './useFetch';
-export * from './useVueQuery';

package/dist/composables/axios/useFetch.d.ts

@@ -1,9 +1,18 @@
 import { AxiosInstance, AxiosRequestConfig } from 'axios';
 import { UseQueryOptions } from '@tanstack/vue-query';
 /**
- * Creates a fetchFn for Axios requests with an optional custom instance.
- * @param fetchComposable - The fn to use for the request (can be any fetch function).
- * @param axiosCustomInstance - An optional custom Axios instance to use for the request.
- * @returns A function that handles the request using the provided fn.
+ * A factory function that creates a reusable query function for making API requests.
+ * It abstracts the Axios instance creation and allows for a custom instance to be provided.
+ * This is particularly useful for creating typed query functions for use with libraries like Vue Query.
+ *
+ * @template TQueryFnData The expected data type of the query function's response.
+ * @template TData The expected data type of the transformed data.
+ * @param {Function} fetchFn - The underlying function that will be called to perform the fetch operation.
+ *   This function should accept an Axios instance, Axios request configuration, and optional query options.
+ * @param {AxiosInstance} [axiosCustomInstance] - An optional custom Axios instance to use for the request.
+ *   If not provided, a default configured instance will be used.
+ * @returns {(axiosRequestConfig: AxiosRequestConfig, options?: UseQueryOptions<TQueryFnData, Error, TData>) => any}
+ *   A new function that takes Axios request configuration and optional query options, and when executed,
+ *   performs the API request using the configured `fetchFn`.
  */
-export declare function useFetch(fetchFn: Function, axiosCustomInstance?: AxiosInstance): (axiosRequestConfig: AxiosRequestConfig, options?: UseQueryOptions) => any;
+export declare function useFetch<TQueryFnData = unknown, TData = TQueryFnData>(fetchFn: Function, axiosCustomInstance?: AxiosInstance): (axiosRequestConfig: AxiosRequestConfig, options?: UseQueryOptions) => any;

package/dist/composables/breakpoints/useBreakpoint.d.ts

@@ -1,7 +1,16 @@
 /**
- * Composable to manage breakpoints using Tailwind CSS and shared window resize listener.
+ * A composable that provides a reactive interface to Tailwind CSS breakpoints using `@vueuse/core`.
+ * It simplifies working with responsive layouts by offering a set of reactive booleans for different
+ * screen sizes and combinations. On its first invocation, it also logs the current device type (Mobile,
+ * Tablet, Laptop, or Desktop) to the console for easier debugging during development.
  *
- * @returns {Object} An object containing the breakpoints and their states.
+ * @returns {object} An object containing various reactive properties for screen sizes, window dimensions, and breakpoint utilities, including:
+ *   - `current`: A ref to the current breakpoint name.
+ *   - `active`: A ref to the currently active breakpoint name.
+ *   - `sm_S`, `md_GE`, etc.: A series of refs indicating if the screen is smaller than, greater than or equal to, or between specific breakpoints.
+ *   - `mobile`, `tablet`, `laptop`, `desktop`: Refs that are true for common device width ranges.
+ *   - `windowWidth`, `windowHeight`: Reactive refs for the window's width and height.
+ *   - `breakpoints`: The original `useBreakpoints` return object from `@vueuse/core`.
  */
 export declare function useBreakpoint(): {
     current: import("vue").ComputedRef<("sm" | "md" | "lg" | "xl" | "2xl")[]>;

package/dist/composables/filters/useFilter.d.ts

@@ -1,13 +1,18 @@
 /**
- * A composable function that filters objects based on a specific field and criteria.
+ * A composable function that filters an array of objects based on a specified field, data type, and criteria.
+ * It supports filtering by date range, string matching (case-insensitive and diacritic-insensitive), number range, and boolean values.
  *
- * @param {Object[]} items - The list of objects to filter.
- * @param {Object} filterConfig - Configuration for the filter, specifying the field, the data type to filter, and the criteria.
- * @param {string} filterConfig.field - The field in the objects to filter.
- * @param {string} filterConfig.type - The data type of the field ('date', 'string', 'number', 'boolean').
- * @param {any} filterConfig.criteria - The criteria for filtering. Can be a date range, a string to search, a number range, or a boolean value.
- *
- * @returns {Object[]} - The filtered list of objects.
+ * @template T A generic type that extends a record of string keys to any value, representing the objects in the array.
+ * @param {T[]} items - The array of objects to be filtered.
+ * @param {object} filterConfig - The configuration object for filtering.
+ * @param {string} filterConfig.field - The name of the field in the objects to filter by.
+ * @param {'date' | 'string' | 'number' | 'boolean'} filterConfig.type - The data type of the field to be filtered.
+ * @param {any} filterConfig.criteria - The criteria for filtering, which varies based on the `type`:
+ *   - For 'date': An object `{ startDate: string, endDate: string }`.
+ *   - For 'string': A string to search for.
+ *   - For 'number': An object `{ min: number, max: number }`.
+ *   - For 'boolean': A boolean value.
+ * @returns {T[]} The filtered array of objects. If the criteria are invalid or not provided, the original array is returned.
  */
 export declare function useFilter<T extends Record<string, any>>(items: T[], filterConfig: {
     field: string;

package/dist/composables/monitoring/useApiActivity.d.ts

@@ -1,10 +1,21 @@
 /**
- * A Vue composable to monitor API activity and manage session timeouts.
- * It tracks the last user activity and automatically logs out the user
- * if no activity is detected within a specified timeout.
- * @param {number} [sessionTimeoutMin=SESSION_TIMEOUT_MINUTES] - The time in minutes after which an inactive session will time out.
- * @param {number} [checkIntervalSec=CHECK_INTERVAL_SECONDS] - The interval in seconds at which the session timeout is checked.
- * @returns {object} An object containing methods to pause, resume, and manually update the activity timestamp.
+ * A composable that monitors API activity to manage session timeouts. It automatically
+ * updates an activity timestamp on each outgoing API request and checks periodically
+ * if the session has expired due to inactivity. If the session times out, it will
+ * automatically log the user out.
+ *
+ * @param {number} [sessionTimeoutMin=SESSION_TIMEOUT_MINUTES] - The session timeout period in minutes.
+ *   Defaults to 30 minutes.
+ * @param {number} [checkIntervalSec=CHECK_INTERVAL_SECONDS] - The interval in seconds at which to check for
+ *   session expiry. Defaults to 60 seconds.
+ * @returns {{
+ *   pause: () => void,
+ *   resume: () => void,
+ *   updateTimestamp: () => void
+ * }} An object with functions to control the activity monitoring:
+ *   - `pause`: Pauses the periodic session check.
+ *   - `resume`: Resumes the periodic session check.
+ *   - `updateTimestamp`: Manually updates the last activity timestamp.
  */
 export declare function useApiActivity(sessionTimeoutMin?: number, checkIntervalSec?: number): {
     pause: import("@vueuse/core").Fn;

package/dist/composables/monitoring/useUserActivity.d.ts

@@ -1,9 +1,24 @@
 /**
- * Hook para detectar la inactividad del usuario.
- * @param timeout - Tiempo en milisegundos antes de considerar al usuario inactivo. Por defecto es 5 minutos.
- * @param useDefaultEvents - Si se deben usar los eventos por defecto (mousemove, keydown, scroll, touchstart).
- * @param customEvents - Lista personalizada de eventos para detectar actividad.
- * @returns Un objeto con el estado de inactividad, funciones para controlar el temporizador y registrar callbacks.
+ * A composable to detect user inactivity. It tracks user interactions and triggers a timeout
+ * if no activity is detected for a specified duration.
+ *
+ * @param {number} [timeout=300000] - The time in milliseconds before the user is considered inactive. Defaults to 5 minutes.
+ * @param {boolean} [useDefaultEvents=true] - Whether to use the default events (mousemove, keydown, scroll, touchstart) to detect activity.
+ * @param {Array<keyof WindowEventMap>} [customEvents=[]] - A list of custom events to detect activity, in addition to the default ones if `useDefaultEvents` is true.
+ * @returns {{
+ *   isInactive: import('vue').Ref<boolean>,
+ *   startInactivityTimer: () => void,
+ *   stopInactivityTimer: () => void,
+ *   resetInactivityTimer: () => void,
+ *   onTimeout: (callback: () => void) => void,
+ *   removeTimeoutCallback: (callback: () => void) => void
+ * }} An object containing:
+ *   - `isInactive`: A ref that becomes `true` when the user is inactive.
+ *   - `startInactivityTimer`: A function to start the inactivity timer.
+ *   - `stopInactivityTimer`: A function to stop the inactivity timer.
+ *   - `resetInactivityTimer`: A function to reset the inactivity timer.
+ *   - `onTimeout`: A function to register a callback that will be executed on timeout.
+ *   - `removeTimeoutCallback`: A function to remove a previously registered callback.
  */
 export declare function useUserInactivity(timeout?: number, useDefaultEvents?: boolean, customEvents?: Array<keyof WindowEventMap>): {
     isInactive: import("vue").Ref<boolean, boolean>;

package/dist/composables/paginators/usePaginator.d.ts

@@ -1,11 +1,19 @@
 import { Ref } from "vue";
 /**
- * Composable to handle pagination logic.
+ * A composable that provides pagination logic based on reactive refs for the current page,
+ * total number of items, and items per page.
  *
- * @param page - Reactive ref for the current page number.
- * @param total - Reactive ref for total number of items.
- * @param pageSize - Reactive ref for number of items per page.
- * @returns An object with pagination controls.
+ * @param {Ref<number>} page - A reactive ref representing the current page number.
+ * @param {Ref<number>} total - A reactive ref representing the total number of items to be paginated.
+ * @param {Ref<number>} pageSize - A reactive ref representing the number of items per page.
+ * @returns {{
+ *   totalPages: import('vue').ComputedRef<number>,
+ *   canFetchNextPage: () => boolean,
+ *   canFetchPreviousPage: () => boolean
+ * }} An object containing:
+ *   - `totalPages`: A computed property that calculates the total number of pages.
+ *   - `canFetchNextPage`: A function that returns `true` if there is a next page.
+ *   - `canFetchPreviousPage`: A function that returns `true` if there is a previous page.
  */
 export declare function usePagination(page: Ref<number>, total: Ref<number>, pageSize: Ref<number>): {
     totalPages: import("vue").ComputedRef<number>;

package/dist/composables/sorters/useSorter.d.ts

@@ -1,14 +1,20 @@
+import { ComputedRef } from "vue";
 /**
- * Custom composable for sorting products based on a selected criterion.
- * @param {Array} items - The array of products to sort.
- * @param {Array} criteriaList - The list of available sorting criteria.
- * @param {Number} selectedCriteria - The currently selected sorting criterion.
- * @returns {ComputedRef<Array>} - The sorted array of products.
+ * A composable that sorts an array of objects based on a selected criterion from a list of predefined sorting options.
+ * It supports sorting by number, date, boolean, and string fields, in both ascending and descending order.
+ *
+ * @template T The type of items in the array.
+ * @param {T[]} items - The array of objects to sort.
+ * @param {Array<{value: number, label: string, field: string, order: string, type: string}>} criteriaList - A list of
+ *   sorting criteria objects. Each object defines a sorting option with a unique `value`, a `label` for display, the `field`
+ *   to sort by, the `order` ('asc' or 'desc'), and the data `type` ('number', 'date', 'boolean', 'string').
+ * @param {number} selectedCriteria - The `value` of the currently selected sorting criterion from the `criteriaList`.
+ * @returns {ComputedRef<T[]>} A computed ref containing the sorted items. If the selected criterion is not found, the original array is returned.
  */
-export declare function useSorter(items: any[], criteriaList: {
+export declare function useSorter<T extends Record<string, any>>(items: T[], criteriaList: {
     value: number;
     label: string;
     field: string;
     order: string;
     type: string;
-}[], selectedCriteria: number): any[];
+}[], selectedCriteria: number): ComputedRef<T[]>;

package/dist/config/auth/authFetcher.d.ts

@@ -0,0 +1,30 @@
+import { Fetcher } from '@/types/Fetcher';
+/**
+ * Configures a default fetcher for authentication operations.
+ * If not configured, useAuth will use the default Axios fetcher.
+ *
+ * @param fetcher - The fetcher function to use for auth operations
+ *
+ * @example
+ * ```typescript
+ * import { configAuthFetcher, createOfetchFetcher } from '@arex95/vue-core';
+ *
+ * const ofetchFetcher = createOfetchFetcher();
+ * configAuthFetcher(ofetchFetcher);
+ * ```
+ */
+export declare function configAuthFetcher(fetcher: Fetcher): void;
+/**
+ * Configures a factory function to create the default fetcher lazily.
+ * This is used internally to avoid circular dependencies.
+ *
+ * @param factory - Factory function that creates a fetcher
+ */
+export declare function setDefaultAuthFetcherFactory(factory: () => Fetcher): void;
+/**
+ * Gets the default auth fetcher, creating one from Axios if not configured.
+ * This allows lazy initialization to avoid circular dependencies.
+ *
+ * @returns The fetcher function to use
+ */
+export declare function getDefaultAuthFetcher(): Fetcher;

package/dist/config/auth/index.d.ts

@@ -0,0 +1 @@
+export * from './authFetcher';

package/dist/config/axios/axiosConfig.d.ts

@@ -5,6 +5,12 @@ declare module "axios" {
         _retry?: boolean;
     }
 }
+/**
+ * A service class that encapsulates a customizable Axios instance with built-in interceptors
+ * for handling authentication, token refreshing, and request cancellation. It is designed to
+ * streamline API communication by automatically attaching authorization headers and managing
+ * token refresh logic for 401 Unauthorized responses.
+ */
 export declare class AxiosService {
     private readonly instance;
     private cancelTokenSource;
@@ -12,13 +18,37 @@ export declare class AxiosService {
     private readonly refreshTokenUrl;
     private isRefreshing;
     private failedQueue;
+    /**
+     * Creates an instance of AxiosService.
+     * @param {AxiosServiceOptions} options - Configuration options for the Axios instance, such as `baseURL`, `timeout`, and custom `headers`.
+     */
     constructor(options: AxiosServiceOptions);
     private processQueue;
     private setAuthHeader;
     private initializeInterceptors;
+    /**
+     * Returns the number of active (in-flight) requests.
+     * @returns {number} The number of active requests.
+     */
     getActiveRequests(): number;
+    /**
+     * Returns the underlying Axios instance.
+     * @returns {AxiosInstance} The Axios instance.
+     */
     getAxiosInstance(): AxiosInstance;
+    /**
+     * Cancels all ongoing requests made by this Axios instance.
+     */
     cancelAllRequests(): void;
+    /**
+     * Sets a default header for all subsequent requests.
+     * @param {string} key - The header key.
+     * @param {string} value - The header value.
+     */
     setHeader(key: string, value: string): void;
+    /**
+     * Removes a default header.
+     * @param {string} key - The header key to remove.
+     */
     removeHeader(key: string): void;
 }

package/dist/config/axios/axiosInstance.d.ts

@@ -1,4 +1,18 @@
 import { AxiosServiceOptions } from "@/types/AxiosServiceOptions";
 import { AxiosInstance } from "axios";
+/**
+ * Configures the singleton Axios service instance for the application.
+ * This function should be called once at the application's entry point to set up
+ * the base URL, headers, and other default configurations for all API requests.
+ *
+ * @param {AxiosServiceOptions} config - The configuration options for the Axios service.
+ */
 export declare const configAxios: (config: AxiosServiceOptions) => void;
+/**
+ * Retrieves the configured singleton Axios instance.
+ * If not configured yet, creates a default instance with minimal configuration.
+ * This allows lazy initialization to avoid dependency circular issues in Nuxt and other frameworks.
+ *
+ * @returns {AxiosInstance} The configured Axios instance.
+ */
 export declare const getConfiguredAxiosInstance: () => AxiosInstance;

package/dist/config/global/endpointsConfig.d.ts

@@ -8,24 +8,20 @@ interface EndpointConfig {
     logoutEndpoint: string;
 }
 /**
- * Configures authentication endpoint URLs globally.
- * This function freezes the object to prevent further modifications.
+ * Configures the global authentication endpoint URLs for the application.
+ * This function should be called once at startup to define the API endpoints for login,
+ * token refresh, and logout. The configuration is then frozen to prevent changes.
  *
- * @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.
+ * @param {EndpointConfig} config - An object containing the URLs for the authentication endpoints.
+ * @param {string} config.loginEndpoint - The URL for the login endpoint.
+ * @param {string} config.refreshEndpoint - The URL for the token refresh endpoint.
+ * @param {string} config.logoutEndpoint - The URL for the logout endpoint.
  */
 export declare function configEndpoints(config: EndpointConfig): void;
 /**
- * Retrieves the configured authentication endpoint URLs.
+ * Retrieves the globally 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.
+ * @returns {EndpointsConfig} A frozen object containing the configured `LOGIN`, `REFRESH`, and `LOGOUT` endpoints.
  */
 export declare function getEndpointsConfig(): EndpointsConfig;
 export {};

package/dist/config/global/keyConfig.d.ts

@@ -1,20 +1,17 @@
 import { AppKeyConfig } from "../../types/AppKeyConfig";
 /**
- * Sets the main application encryption key.
- * This key is expected to be used for encryption purposes within the application.
+ * Sets the main application key, which is intended for use in encryption and signing operations.
+ * This function should be called once at application startup to configure the key.
  *
- * @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.
+ * @param {AppKeyConfig} config - An object containing the application key.
+ * @param {string} config.appKey - The application key.
  * @throws {Error} If the provided key is null, undefined, or an empty string.
  */
 export declare function configAppKey(config: AppKeyConfig): void;
 /**
- * Retrieves the current application encryption key.
- * Throws an error if the application key has not been configured.
+ * Retrieves the configured application key.
  *
- * @returns {string} The configured application encryption key.
- * @throws {Error} If the application encryption key has not been set.
+ * @returns {string} The configured application key.
+ * @throws {Error} If the application key has not been set by calling `configAppKey` first.
  */
 export declare function getAppKey(): string;

package/dist/config/global/sessionConfig.d.ts

@@ -1,34 +1,32 @@
 import { LocationPreference, SessionConfigObject, SessionConfig } from "@/types/SessionConfig";
 /**
- * Configures the session identifier and/or data persistence preference
- * for the active browser session.
+ * Configures the session ID and persistence preference for the application.
+ * This function allows setting a custom session ID and specifying whether session-related
+ * data should be stored in `localStorage` or `sessionStorage`. The configuration is
+ * then encrypted and saved to the chosen storage.
  *
- * 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.
+ * @param {SessionConfigObject} config - An object containing the session configuration.
+ * @param {string} [config.sessionId] - A unique identifier for the session. If not provided, the existing one is maintained.
+ * @param {LocationPreference} [config.persistencePreference] - The storage location ('local' or 'session').
+ *   If not provided, the existing preference is maintained.
+ * @returns {Promise<void>} A promise that resolves once the session has been configured and saved.
  */
 export declare function configSession(config: SessionConfigObject): Promise<void>;
 /**
- * Retrieves the current session identifier.
- * Always attempts to load the configuration from storage. If it fails, it uses the internal state.
+ * Retrieves the current session identifier, loading it from storage if available.
  *
- * @returns {Promise<string>} A promise that resolves with the unique session identifier.
+ * @returns {Promise<string>} A promise that resolves with the session ID.
  */
 export declare function getSessionId(): Promise<string>;
 /**
- * Retrieves the current data persistence preference.
- * Always attempts to load the configuration from storage. If it fails, it uses the internal state.
+ * Retrieves the current data persistence preference, loading it from storage if available.
  *
- * @returns {Promise<SessionPreference>} A promise that resolves with the configured persistence preference ('local' or 'session').
+ * @returns {Promise<LocationPreference>} A promise that resolves with the persistence preference ('local' or 'session').
  */
 export declare function getSessionPersistence(): Promise<LocationPreference>;
 /**
- * Retrieves the complete session configuration.
- * Always attempts to load the configuration from storage. If it fails, it uses the internal state.
+ * Retrieves the complete session configuration object, loading it from storage if available.
  *
- * @returns {Promise<SessionConfig>} A promise that resolves with the session configuration object.
+ * @returns {Promise<SessionConfig>} A promise that resolves with the full session configuration.
  */
 export declare function getSessionConfig(): Promise<SessionConfig>;