@arex95/vue-core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 arexdev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# npm-arex-core
+arex core npm distribution

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

@@ -0,0 +1,10 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+/**
+ * Custom composable function for making API requests with Axios.
+ *
+ * @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.
+ */
+export default function axiosFetch<T>(axios: AxiosInstance, axiosRequest: AxiosRequestConfig): Promise<T>;

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

@@ -0,0 +1,10 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { UseQueryOptions } from '@tanstack/vue-query';
+/**
+ * Creates a fetchComposable for Axios requests with an optional custom instance.
+ * @param fetchComposable - The composable to use for the request (can be any fetch function).
+ * @param apiUrl - The base URL for the Axios instance.
+ * @param axiosInstance - An optional custom Axios instance to use for the request.
+ * @returns A function that handles the request using the provided composable.
+ */
+export default function createFetch(fetchComposable: Function, apiUrl: string, axiosInstance?: AxiosInstance): (axiosRequestConfig: AxiosRequestConfig, options?: UseQueryOptions) => any;

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

@@ -0,0 +1,3 @@
+export * from './axiosFetch';
+export * from './createFetch';
+export * from './useVueQuery';

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

@@ -0,0 +1,192 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+import type { ExtendedQueryOptions } from '../../types';
+/**
+ * Custom composable for integrating Axios requests with Vue Query.
+ *
+ * @template T - The type of data expected from the query.
+ * @param {AxiosInstance} axios - Axios instance used for making HTTP requests.
+ * @param {AxiosRequestConfig} axiosRequest - Initial Axios request configuration.
+ * @param {ExtendedQueryOptions<T>} [queryOptions] - Optional Vue Query options with server execution flag.
+ * @returns {object} Composable functions and query state for managing API requests.
+ */
+export default function useVueQuery<T>(axios: AxiosInstance, axiosRequest: AxiosRequestConfig, queryOptions?: ExtendedQueryOptions): {
+    data: import("vue").Ref<T, T>;
+    error: import("vue").Ref<unknown, unknown>;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isLoading: import("vue").Ref<false, false>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<true, true>;
+    isSuccess: import("vue").Ref<false, false>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"error", "error">;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<unknown, unknown>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<T>, Promise<T>>;
+    suspense: () => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    execute: (newKey?: Array<any>, newRequestParams?: object, newQueryOptions?: ExtendedQueryOptions) => void;
+    onResult: (cb: (data: T) => void) => void;
+    onError: (callback: (e: unknown) => void) => void;
+} | {
+    data: import("vue").Ref<T, T>;
+    error: import("vue").Ref<null, null>;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isLoading: import("vue").Ref<false, false>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"success", "success">;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<unknown, unknown>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<T>, Promise<T>>;
+    suspense: () => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    execute: (newKey?: Array<any>, newRequestParams?: object, newQueryOptions?: ExtendedQueryOptions) => void;
+    onResult: (cb: (data: T) => void) => void;
+    onError: (callback: (e: unknown) => void) => void;
+} | {
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<unknown, unknown>;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isLoading: import("vue").Ref<false, false>;
+    isLoadingError: import("vue").Ref<true, true>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"error", "error">;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<unknown, unknown>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<T>, Promise<T>>;
+    suspense: () => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    execute: (newKey?: Array<any>, newRequestParams?: object, newQueryOptions?: ExtendedQueryOptions) => void;
+    onResult: (cb: (data: T) => void) => void;
+    onError: (callback: (e: unknown) => void) => void;
+} | {
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isLoading: import("vue").Ref<true, true>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"pending", "pending">;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<unknown, unknown>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<T>, Promise<T>>;
+    suspense: () => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    execute: (newKey?: Array<any>, newRequestParams?: object, newQueryOptions?: ExtendedQueryOptions) => void;
+    onResult: (cb: (data: T) => void) => void;
+    onError: (callback: (e: unknown) => void) => void;
+} | {
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"pending", "pending">;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<unknown, unknown>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<T>, Promise<T>>;
+    suspense: () => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    execute: (newKey?: Array<any>, newRequestParams?: object, newQueryOptions?: ExtendedQueryOptions) => void;
+    onResult: (cb: (data: T) => void) => void;
+    onError: (callback: (e: unknown) => void) => void;
+} | {
+    data: import("vue").Ref<T, T>;
+    isError: import("vue").Ref<false, false>;
+    error: import("vue").Ref<null, null>;
+    isPending: import("vue").Ref<false, false>;
+    isLoading: import("vue").Ref<false, false>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    isPlaceholderData: import("vue").Ref<true, true>;
+    status: import("vue").Ref<"success", "success">;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<unknown, unknown>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<T>, Promise<T>>;
+    suspense: () => Promise<import("@tanstack/vue-query").QueryObserverResult<T, unknown>>;
+    execute: (newKey?: Array<any>, newRequestParams?: object, newQueryOptions?: ExtendedQueryOptions) => void;
+    onResult: (cb: (data: T) => void) => void;
+    onError: (callback: (e: unknown) => void) => void;
+};

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

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

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

@@ -0,0 +1,62 @@
+/**
+ * Composable to manage breakpoints using Tailwind CSS and shared window resize listener.
+ *
+ * @returns {Object} An object containing the breakpoints and their states.
+ */
+export default function useBreakpoint(): {
+    current: import("vue").ComputedRef<("sm" | "md" | "lg" | "xl" | "2xl")[]>;
+    active: import("vue").ComputedRef<"" | "sm" | "md" | "lg" | "xl" | "2xl">;
+    sm_S: import("vue").ComputedRef<boolean>;
+    sm_SE: import("vue").ComputedRef<boolean>;
+    sm_GE: import("vue").ComputedRef<boolean>;
+    sm_md: import("vue").ComputedRef<boolean>;
+    sm_xl: import("vue").ComputedRef<boolean>;
+    sm_2xl: import("vue").ComputedRef<boolean>;
+    md_S: import("vue").ComputedRef<boolean>;
+    md_SE: import("vue").ComputedRef<boolean>;
+    md_GE: import("vue").ComputedRef<boolean>;
+    md_lg: import("vue").ComputedRef<boolean>;
+    md_xl: import("vue").ComputedRef<boolean>;
+    md_2xl: import("vue").ComputedRef<boolean>;
+    lg_S: import("vue").ComputedRef<boolean>;
+    lg_SE: import("vue").ComputedRef<boolean>;
+    lg_GE: import("vue").ComputedRef<boolean>;
+    lg_xl: import("vue").ComputedRef<boolean>;
+    lg_2xl: import("vue").ComputedRef<boolean>;
+    xl_S: import("vue").ComputedRef<boolean>;
+    xl_SE: import("vue").ComputedRef<boolean>;
+    xl_GE: import("vue").ComputedRef<boolean>;
+    xl_2xl: import("vue").ComputedRef<boolean>;
+    _2xl_S: import("vue").ComputedRef<boolean>;
+    _2xl_SE: import("vue").ComputedRef<boolean>;
+    _2xl_GE: import("vue").ComputedRef<boolean>;
+    isGreaterThanBreakpoint: import("vue").ComputedRef<boolean>;
+    reactiveBreakpoint: import("vue").Ref<"sm" | "md" | "lg" | "xl" | "2xl", "sm" | "md" | "lg" | "xl" | "2xl">;
+    breakpointsTailwind: {
+        sm: number;
+        md: number;
+        lg: number;
+        xl: number;
+        '2xl': number;
+    };
+    windowWidth: import("vue").ShallowRef<number, number>;
+    windowHeight: import("vue").ShallowRef<number, number>;
+    mobile: import("vue").ComputedRef<boolean>;
+    tablet: import("vue").ComputedRef<boolean>;
+    laptop: import("vue").ComputedRef<boolean>;
+    desktop: import("vue").ComputedRef<boolean>;
+    breakpoints: Record<"sm" | "md" | "lg" | "xl" | "2xl", import("vue").ComputedRef<boolean>> & {
+        greaterOrEqual: (k: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">) => import("vue").ComputedRef<boolean>;
+        smallerOrEqual: (k: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">) => import("vue").ComputedRef<boolean>;
+        greater(k: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">): import("vue").ComputedRef<boolean>;
+        smaller(k: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">): import("vue").ComputedRef<boolean>;
+        between(a: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">, b: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">): import("vue").ComputedRef<boolean>;
+        isGreater(k: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">): boolean;
+        isGreaterOrEqual(k: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">): boolean;
+        isSmaller(k: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">): boolean;
+        isSmallerOrEqual(k: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">): boolean;
+        isInBetween(a: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">, b: import("vue").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl" | "2xl">): boolean;
+        current: () => import("vue").ComputedRef<("sm" | "md" | "lg" | "xl" | "2xl")[]>;
+        active(): import("vue").ComputedRef<"" | "sm" | "md" | "lg" | "xl" | "2xl">;
+    };
+};

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * A composable function that filters objects based on a specific field and criteria.
+ *
+ * @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.
+ */
+export default function useFilter<T extends Record<string, any>>(items: T[], filterConfig: {
+    field: string;
+    type: 'date' | 'string' | 'number' | 'boolean';
+    criteria: any;
+}): T[];

package/dist/composables/index.d.ts

@@ -0,0 +1,5 @@
+export * from './axios';
+export * from './breakpoints';
+export * from './filters';
+export * from './paginators';
+export * from './sorters';

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

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

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

@@ -0,0 +1,14 @@
+import { Ref } from "vue";
+/**
+ * Composable to handle pagination logic.
+ *
+ * @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.
+ */
+export default function usePagination(page: Ref<number>, total: Ref<number>, pageSize: Ref<number>): {
+    totalPages: import("vue").ComputedRef<number>;
+    canFetchNextPage: () => boolean;
+    canFetchPreviousPage: () => boolean;
+};

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+export declare function useSorter(items: any[], criteriaList: {
+    value: number;
+    label: string;
+    field: string;
+    order: string;
+    type: string;
+}[], selectedCriteria: number): any[];

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

@@ -0,0 +1,47 @@
+import { AxiosInstance } from 'axios';
+/**
+ * AxiosService class encapsulates the Axios configuration and logic.
+ * It manages request and response interceptors and provides methods for making HTTP requests.
+ */
+export default class AxiosService {
+    private readonly instance;
+    private cancelTokenSource;
+    private activeRequests;
+    /**
+     * Initializes the AxiosService instance by creating an Axios instance with default configuration
+     * and setting up request and response interceptors.
+     */
+    constructor(url: string);
+    /**
+     * Initializes request and response interceptors for the Axios instance.
+     */
+    private initializeInterceptors;
+    /**
+     * Returns the number of active requests.
+     */
+    getActiveRequests(): number;
+    /**
+     * Handles unauthorized access errors (401).
+     */
+    private handleUnauthorized;
+    /**
+     * Returns the Axios instance with the configured settings and interceptors.
+     * @returns {AxiosInstance} The configured Axios instance.
+     */
+    getAxiosInstance(): AxiosInstance;
+    /**
+     * Cancels all ongoing requests.
+     */
+    cancelAllRequests(): void;
+    /**
+     * Sets a new header for the Axios instance.
+     * @param {string} key - The header key.
+     * @param {string} value - The header value.
+     */
+    setHeader(key: string, value: string): void;
+    /**
+     * Removes a header from the Axios instance.
+     * @param {string} key - The header key to remove.
+     */
+    removeHeader(key: string): void;
+}

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

@@ -0,0 +1,2 @@
+export * from './axiosConfig';
+export { default as AxiosService } from './axiosConfig';

package/dist/config/index.d.ts

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

package/dist/constants/breakpointEnum.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Object defining available screen sizes as constants.
+ * @readonly
+ */
+export declare const sizeEnum: {
+    readonly XS: "XS";
+    readonly SM: "SM";
+    readonly MD: "MD";
+    readonly LG: "LG";
+    readonly XL: "XL";
+    readonly XXL: "XXL";
+};
+/**
+ * Object defining breakpoints for design based on screen width.
+ * Values are in pixels.
+ * @readonly
+ */
+export declare const screenEnum: {
+    readonly XS: 480;
+    readonly SM: 576;
+    readonly MD: 768;
+    readonly LG: 992;
+    readonly XL: 1200;
+    readonly XXL: 1600;
+};
+/**
+ * Map that associates each screen size defined in `sizeEnum` with its corresponding pixel value from `screenEnum`.
+ * @type {Map<typeof sizeEnum[keyof typeof sizeEnum], number>}
+ */
+declare const screenMap: Map<"XS" | "SM" | "MD" | "LG" | "XL" | "XXL", number>;
+export { screenMap };

package/dist/constants/exceptionEnum.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Object defining various exception codes.
+ * @readonly
+ */
+export declare const ExceptionEnum: {
+    /**
+     * HTTP status code for page access forbidden.
+     */
+    readonly PAGE_NOT_ACCESS: 403;
+    /**
+     * HTTP status code for page not found.
+     */
+    readonly PAGE_NOT_FOUND: 404;
+    /**
+     * HTTP status code for general server error.
+     */
+    readonly ERROR: 500;
+    /**
+     * HTTP status code for bad request.
+     */
+    readonly BAD_REQUEST: 406;
+    /**
+     * Custom error code for network errors.
+     */
+    readonly NET_WORK_ERROR: 10000;
+    /**
+     * Custom code indicating no data on the page, not actually an exception page.
+     */
+    readonly PAGE_NOT_DATA: 10100;
+};

package/dist/constants/fileTypesEnum.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Object defining various image MIME types.
+ * @readonly
+ */
+export declare const ImageTypes: {
+    readonly apng: "image/apng";
+    readonly bmp: "image/bmp";
+    readonly gif: "image/gif";
+    readonly jpeg: "image/jpeg";
+    readonly pjpeg: "image/pjpeg";
+    readonly png: "image/png";
+    readonly svg: "image/svg+xml";
+    readonly tiff: "image/tiff";
+    readonly webp: "image/webp";
+    readonly xicon: "image/x-icon";
+};
+/**
+ * Object defining various file meta types.
+ * @readonly
+ */
+export declare const FileMetaTypes: {
+    readonly images: "image/*";
+    readonly audios: "audio/*";
+    readonly videos: "video/*";
+};

package/dist/constants/httpEnum.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Object representing different content types for HTTP headers.
+ * @readonly
+ */
+export declare const ContentTypeEnum: {
+    /**
+     * Content type for JSON.
+     * @constant
+     */
+    readonly JSON: "application/json;charset=UTF-8";
+    /**
+     * Content type for URL-encoded form data.
+     * @constant
+     */
+    readonly FORM_URLENCODED: "application/x-www-form-urlencoded;charset=UTF-8";
+    /**
+     * Content type for multipart form data with file uploads.
+     * @constant
+     */
+    readonly FORM_DATA: "multipart/form-data;charset=UTF-8";
+};

package/dist/constants/index.d.ts

@@ -0,0 +1,6 @@
+export * from './breakpointEnum';
+export * from './exceptionEnum';
+export * from './fileTypesEnum';
+export * from './httpEnum';
+export * from './keyCodeEnum';
+export * from './storageEnum';

package/dist/constants/keyCodeEnum.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Object defining various key codes for keyboard events.
+ * @readonly
+ */
+export declare const KeyCodeEnum: {
+    readonly UP: 38;
+    readonly DOWN: 40;
+    readonly ENTER: 13;
+    readonly ESC: 27;
+};

package/dist/constants/storageEnum.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Key used for storing the authentication token.
+ * @constant {string}
+ */
+export declare const TOKEN_KEY = "TOKEN__";
+/**
+ * Key used for storing the locale information.
+ * @constant {string}
+ */
+export declare const LOCALE_KEY = "LOCALE__";
+/**
+ * Key used for storing user information.
+ * @constant {string}
+ */
+export declare const USER_INFO_KEY = "USER__INFO__";
+/**
+ * Key used for storing role information.
+ * @constant {string}
+ */
+export declare const ROLES_KEY = "ROLES__KEY__";
+/**
+ * Key used for storing project configuration.
+ * @constant {string}
+ */
+export declare const PROJ_CFG_KEY = "PROJ__CFG__KEY__";
+/**
+ * Key used for storing lock information.
+ * @constant {string}
+ */
+export declare const LOCK_INFO_KEY = "LOCK__INFO__KEY__";
+/**
+ * Key used for base global local cache.
+ * @constant {string}
+ */
+export declare const APP_LOCAL_CACHE_KEY = "COMMON__LOCAL__KEY";
+/**
+ * Key used for base global session cache.
+ * @constant {string}
+ */
+export declare const APP_SESSION_CACHE_KEY = "COMMON__SESSION__KEY";
+/**
+ * Object defining types of cache storage.
+ * @readonly
+ */
+export declare const CacheTypeEnum: {
+    /** Represents session storage */
+    readonly SESSION: 0;
+    /** Represents local storage */
+    readonly LOCAL: 1;
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './rest';
+export * from './composables';
+export * from './config';
+export * from './constants';
+export * from './types';
+export * from './utils';