@ametie/vue-muza-use 0.6.1 → 0.7.0

package/dist/index.cjs

@@ -75,17 +75,34 @@ function useApiConfig() {
 }
 
 // src/utils/debounce.ts
+var DebounceCancelledError = class extends Error {
+  isDebounceCancelled = true;
+  constructor() {
+    super("Debounced call was superseded by a newer call");
+    this.name = "DebounceCancelledError";
+  }
+};
 function debounceFn(fn, delay) {
   let timeoutId = null;
+  let pendingReject = null;
   return function(...args) {
-    return new Promise((resolve) => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
+    if (pendingReject) {
+      pendingReject(new DebounceCancelledError());
+      pendingReject = null;
+    }
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    return new Promise((resolve, reject) => {
+      pendingReject = reject;
       timeoutId = setTimeout(async () => {
-        const result = await fn(...args);
-        resolve(result);
+        pendingReject = null;
         timeoutId = null;
+        try {
+          resolve(await fn(...args));
+        } catch (err) {
+          reject(err);
+        }
       }, delay);
     });
   };
@@ -196,6 +213,26 @@ function useAbortController() {
 }
 
 // src/useApi.ts
+var DEFAULT_RETRY_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+function cancellableSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve(true);
+      return;
+    }
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve(false);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      cleanup();
+      resolve(true);
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function useApi(url, options = {}) {
   const { axios: axios2, onError: globalErrorHandler, globalOptions, errorParser } = useApiConfig();
   const {
@@ -210,12 +247,14 @@ function useApi(url, options = {}) {
     skipErrorNotification = false,
     retry = globalOptions?.retry ?? false,
     retryDelay = globalOptions?.retryDelay ?? 1e3,
+    retryStatusCodes = globalOptions?.retryStatusCodes ?? DEFAULT_RETRY_STATUS_CODES,
     authMode = "default",
     useGlobalAbort = globalOptions?.useGlobalAbort ?? true,
     initialLoading = false,
     poll = 0,
     ...axiosConfig
   } = options;
+  const maxRetries = retry === false ? 0 : retry === true ? 3 : retry;
   const startLoading = initialLoading ?? immediate;
   const state = useApiState(initialData, { initialLoading: startLoading });
   const abortController2 = (0, import_vue4.ref)(null);
@@ -255,28 +294,57 @@ function useApi(url, options = {}) {
     state.setLoading(true);
     state.setError(null);
     let wasCancelled = false;
+    let retryCount = 0;
     try {
+      if (!requestUrl) {
+        throw new Error("Request URL is missing");
+      }
       const rawData = config?.data !== void 0 ? config.data : axiosConfig.data;
       const resolvedData = (0, import_vue4.toValue)(rawData);
       const rawParams = config?.params !== void 0 ? config.params : axiosConfig.params;
       const resolvedParams = (0, import_vue4.toValue)(rawParams);
-      if (!requestUrl) {
-        throw new Error("Request URL is missing");
+      while (true) {
+        try {
+          const response = await axios2.request({
+            url: requestUrl,
+            method,
+            ...axiosConfig,
+            ...config,
+            data: resolvedData,
+            params: resolvedParams,
+            signal: controller.signal,
+            ...{ authMode: config?.authMode || authMode }
+          });
+          state.mutate(response.data, response);
+          state.setStatusCode(response.status);
+          onSuccess?.(response);
+          return response.data;
+        } catch (err) {
+          if (controller.signal.aborted || (0, import_axios2.isAxiosError)(err) && err.code === "ERR_CANCELED") {
+            wasCancelled = true;
+            return null;
+          }
+          const apiError = errorParser ? errorParser(err) : parseApiError(err);
+          const canRetry = retryCount < maxRetries && (retryStatusCodes.length === 0 || retryStatusCodes.includes(apiError.status));
+          if (canRetry) {
+            retryCount++;
+            const aborted = await cancellableSleep(retryDelay, controller.signal);
+            if (aborted) {
+              wasCancelled = true;
+              state.setLoading(false);
+              return null;
+            }
+            continue;
+          }
+          if (!skipErrorNotification && globalErrorHandler) {
+            globalErrorHandler(apiError, err);
+          }
+          state.setError(apiError);
+          state.setStatusCode(apiError.status);
+          onError?.(apiError);
+          return null;
+        }
       }
-      const response = await axios2.request({
-        url: requestUrl,
-        method,
-        ...axiosConfig,
-        ...config,
-        data: resolvedData,
-        params: resolvedParams,
-        signal: controller.signal,
-        ...{ authMode: config?.authMode || authMode }
-      });
-      state.mutate(response.data, response);
-      state.setStatusCode(response.status);
-      onSuccess?.(response);
-      return response.data;
     } catch (err) {
       if (controller.signal.aborted || (0, import_axios2.isAxiosError)(err) && err.code === "ERR_CANCELED") {
         wasCancelled = true;
@@ -311,7 +379,11 @@ function useApi(url, options = {}) {
       }
     }
   };
-  const execute = debounce > 0 ? debounceFn(executeRequest, debounce) : executeRequest;
+  const _debounced = debounce > 0 ? debounceFn(executeRequest, debounce) : null;
+  const execute = _debounced ? (config) => _debounced(config).catch((err) => {
+    if (err instanceof DebounceCancelledError) return null;
+    throw err;
+  }) : executeRequest;
   const abort = (msg) => {
     if (pollTimer) clearTimeout(pollTimer);
     abortController2.value?.abort(msg);
@@ -383,7 +455,11 @@ function useApiDelete(url, options) {
 
 // src/useApiBatch.ts
 var import_vue5 = require("vue");
-function useApiBatch(urls, options = {}) {
+function normalizeRequest(item) {
+  if (typeof item === "string") return { url: item, method: "GET" };
+  return { method: "GET", ...item };
+}
+function useApiBatch(requests, options = {}) {
   const {
     settled = true,
     concurrency,
@@ -396,7 +472,7 @@ function useApiBatch(urls, options = {}) {
     onProgress,
     ...apiOptions
   } = options;
-  const getUrls = () => (0, import_vue5.toValue)(urls);
+  const getRequests = () => (0, import_vue5.toValue)(requests).map(normalizeRequest);
   const data = (0, import_vue5.ref)([]);
   const loading = (0, import_vue5.ref)(false);
   const error = (0, import_vue5.ref)(null);
@@ -414,43 +490,54 @@ function useApiBatch(urls, options = {}) {
   const abortControllers = (0, import_vue5.ref)([]);
   let isAborted = false;
   const updateProgress = (succeeded, failed) => {
-    const currentUrls = getUrls();
+    const currentRequests = getRequests();
     const completed = succeeded + failed;
     const newProgress = {
       completed,
-      total: currentUrls.length,
-      percentage: currentUrls.length > 0 ? Math.round(completed / currentUrls.length * 100) : 0,
+      total: currentRequests.length,
+      percentage: currentRequests.length > 0 ? Math.round(completed / currentRequests.length * 100) : 0,
       succeeded,
       failed
     };
     progress.value = newProgress;
     onProgress?.(newProgress);
   };
-  const executeRequest = async (url, index, signal) => {
-    const { execute: execute2, error: reqError, statusCode } = useApi(url, {
+  const executeRequest = async (config, index, signal) => {
+    const scope = (0, import_vue5.effectScope)();
+    const api = scope.run(() => useApi(config.url, {
       ...apiOptions,
+      method: config.method,
+      data: config.data,
+      params: config.params,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ...config.headers && { headers: config.headers },
       useGlobalAbort: false,
       skipErrorNotification
-    });
+    }));
+    const { execute: execute2, error: reqError, statusCode, response } = api;
     try {
       const result = await execute2({ signal });
       if (signal.aborted) {
         return {
-          url,
+          url: config.url,
           index,
           success: false,
           data: null,
           error: { message: "Request aborted", status: 0, code: "ABORTED" },
-          statusCode: null
+          statusCode: null,
+          response: null,
+          request: config
         };
       }
       const item = {
-        url,
+        url: config.url,
         index,
         success: result !== null && result !== void 0,
         data: result ?? null,
         error: reqError.value,
-        statusCode: statusCode.value
+        statusCode: statusCode.value,
+        response: response.value,
+        request: config
       };
       if (item.success) {
         onItemSuccess?.(item, index);
@@ -465,26 +552,30 @@ function useApiBatch(urls, options = {}) {
         code: "BATCH_ERROR"
       };
       const item = {
-        url,
+        url: config.url,
         index,
         success: false,
         data: null,
         error: apiError,
-        statusCode: null
+        statusCode: null,
+        response: null,
+        request: config
       };
       onItemError?.(item, index);
       return item;
+    } finally {
+      scope.stop();
     }
   };
-  const executeWithConcurrency = async (urls2, limit) => {
-    const results = new Array(urls2.length);
+  const executeWithConcurrency = async (requests2, limit) => {
+    const results = new Array(requests2.length);
     let succeededCount = 0;
     let failedCount = 0;
-    if (!limit || limit >= urls2.length) {
-      const promises = urls2.map((url, index) => {
+    if (!limit || limit >= requests2.length) {
+      const promises = requests2.map((config, index) => {
         const controller = new AbortController();
         abortControllers.value.push(controller);
-        return executeRequest(url, index, controller.signal).then((result) => {
+        return executeRequest(config, index, controller.signal).then((result) => {
           results[index] = result;
           if (result.success) {
             succeededCount++;
@@ -509,12 +600,12 @@ function useApiBatch(urls, options = {}) {
     } else {
       let currentIndex = 0;
       const executeNext = async () => {
-        while (currentIndex < urls2.length && !isAborted) {
+        while (currentIndex < requests2.length && !isAborted) {
           const index = currentIndex++;
-          const url = urls2[index];
+          const config = requests2[index];
           const controller = new AbortController();
           abortControllers.value.push(controller);
-          const result = await executeRequest(url, index, controller.signal);
+          const result = await executeRequest(config, index, controller.signal);
           results[index] = result;
           if (result.success) {
             succeededCount++;
@@ -531,7 +622,7 @@ function useApiBatch(urls, options = {}) {
           }
         }
       };
-      const workers = Array.from({ length: Math.min(limit, urls2.length) }, () => executeNext());
+      const workers = Array.from({ length: Math.min(limit, requests2.length) }, () => executeNext());
       if (settled) {
         await Promise.allSettled(workers);
       } else {
@@ -541,7 +632,7 @@ function useApiBatch(urls, options = {}) {
     return results;
   };
   const execute = async () => {
-    const currentUrls = getUrls();
+    const currentRequests = getRequests();
     isAborted = false;
     loading.value = true;
     error.value = null;
@@ -550,7 +641,7 @@ function useApiBatch(urls, options = {}) {
     abortControllers.value = [];
     updateProgress(0, 0);
     try {
-      const results = await executeWithConcurrency(currentUrls, concurrency);
+      const results = await executeWithConcurrency(currentRequests, concurrency);
       data.value = results;
       const allFailed = results.every((r) => !r.success);
       if (allFailed && results.length > 0) {
@@ -587,7 +678,7 @@ function useApiBatch(urls, options = {}) {
     data.value = [];
     progress.value = {
       completed: 0,
-      total: getUrls().length,
+      total: getRequests().length,
       percentage: 0,
       succeeded: 0,
       failed: 0
@@ -779,16 +870,16 @@ var tokenManager = new TokenManager();
 // src/features/interceptors.ts
 var AUTH_HEADER = "Authorization";
 var TOKEN_TYPE2 = "Bearer";
-var failedQueue = [];
-var isRefreshing = false;
-function processQueue(error, token = null) {
-  failedQueue.forEach((promise) => {
-    if (error) promise.reject(error);
-    else if (token) promise.resolve(token);
-  });
-  failedQueue = [];
-}
 function setupInterceptors(axiosInstance, options = {}) {
+  let failedQueue = [];
+  let isRefreshing = false;
+  function processQueue(error, token = null) {
+    failedQueue.forEach((promise) => {
+      if (error) promise.reject(error);
+      else if (token) promise.resolve(token);
+    });
+    failedQueue = [];
+  }
   const {
     refreshUrl = "/auth/refresh",
     refreshWithCredentials = false,

package/dist/index.d.cts

@@ -23,6 +23,12 @@ interface ApiRequestConfig<D = unknown> extends Omit<AxiosRequestConfig<D>, "dat
     authMode?: AuthMode;
     retry?: boolean | number;
     retryDelay?: number;
+    /**
+     * Retry only when the response status code is in this list.
+     * Default: [408, 429, 500, 502, 503, 504]
+     * Empty array = retry on any error (network errors included).
+     */
+    retryStatusCodes?: number[];
 }
 interface UseApiOptions<T = unknown, D = unknown> extends ApiRequestConfig<D> {
     immediate?: boolean;
@@ -86,6 +92,7 @@ interface ApiPluginOptions {
     globalOptions?: {
         retry?: number | boolean;
         retryDelay?: number;
+        retryStatusCodes?: number[];
         useGlobalAbort?: boolean;
     };
 }
@@ -94,6 +101,23 @@ interface AuthTokens$1 {
     refreshToken?: string;
     expiresIn?: number;
 }
+/**
+ * Per-request configuration for a single item in a batch operation.
+ * String items in the batch array are automatically normalized to this shape
+ * with method: 'GET' and no data/params/headers.
+ */
+interface BatchRequestConfig<D = unknown> {
+    /** The URL to request */
+    url: string;
+    /** HTTP method. Default: 'GET' */
+    method?: string;
+    /** Request body (for POST, PUT, PATCH) */
+    data?: D;
+    /** Query parameters */
+    params?: D;
+    /** Per-request headers that override global defaults for this request only */
+    headers?: Record<string, string>;
+}
 /**
  * Result of a single request in a batch operation
  */
@@ -110,6 +134,10 @@ interface BatchResultItem<T = unknown> {
     error: ApiError | null;
     /** HTTP status code */
     statusCode: number | null;
+    /** Full AxiosResponse (null if failed — headers, status, etc. accessible here) */
+    response: AxiosResponse<T> | null;
+    /** The original normalized request config that produced this result */
+    request: BatchRequestConfig;
 }
 /**
  * Progress information for batch operations
@@ -239,7 +267,9 @@ declare function useApiDelete<T = unknown>(url: MaybeRefOrGetter<string | undefi
  *
  * Features:
  * - Reactive loading, data, error, progress states
- * - Reactive urls support (MaybeRefOrGetter)
+ * - Reactive request list support (MaybeRefOrGetter)
+ * - Per-request method, data, params, headers configuration
+ * - Full backward compatibility — plain string arrays still work
  * - Error tolerance with `settled: true` (default)
  * - Concurrency limiting
  * - Abort support for all pending requests
@@ -249,43 +279,29 @@ declare function useApiDelete<T = unknown>(url: MaybeRefOrGetter<string | undefi
  *
  * @example
  * ```ts
- * // Basic usage - fetch multiple users
- * const { data, loading, progress, execute } = useApiBatch<User>([
- *   '/users/1',
- *   '/users/2',
- *   '/users/3'
- * ])
+ * // Basic usage — plain strings (backward compatible)
+ * const { data, execute } = useApiBatch(['/users/1', '/users/2'])
  *
- * await execute()
- * console.log(data.value) // BatchResultItem<User>[]
+ * // Per-request config — method, data, params, headers
+ * const { data } = useApiBatch([
+ *   { url: '/users', params: { page: 1 } },
+ *   { url: '/posts', method: 'POST', data: { title: 'New' } },
+ *   '/health',  // string and object can be mixed
+ * ])
  *
- * // With reactive urls
- * const userIds = ref([1, 2, 3])
- * const urls = computed(() => userIds.value.map(id => `/users/${id}`))
- * const { successfulData } = useApiBatch<User>(urls, { immediate: true })
+ * // Batch DELETE by IDs
+ * const ids = [1, 2, 3]
+ * useApiBatch(ids.map(id => ({ url: `/users/${id}`, method: 'DELETE' })))
  *
- * // With options
- * const { successfulData, errors, progress } = useApiBatch<Post>(
- *   ['/posts/1', '/posts/2', '/posts/3'],
- *   {
- *     concurrency: 2,        // Max 2 parallel requests
- *     immediate: true,       // Execute on mount
- *     onProgress: (p) => console.log(`${p.percentage}%`)
- *   }
+ * // Reactive getter with object configs
+ * const pages = ref([1, 2, 3])
+ * const { successfulData } = useApiBatch(
+ *   () => pages.value.map(page => ({ url: '/users', params: { page } })),
+ *   { watch: pages, immediate: true }
  * )
- *
- * // Strict mode - fail on first error
- * const { execute } = useApiBatch<User>(urls, { settled: false })
- *
- * // Auto re-execute when dependency changes
- * const filters = ref({ status: 'active' })
- * const { data } = useApiBatch<User>(urls, {
- *   watch: filters,
- *   immediate: true
- * })
  * ```
  */
-declare function useApiBatch<T = unknown>(urls: MaybeRefOrGetter<string[]>, options?: UseApiBatchOptions<T>): UseApiBatchReturn<T>;
+declare function useApiBatch<T = unknown>(requests: MaybeRefOrGetter<Array<string | BatchRequestConfig>>, options?: UseApiBatchOptions<T>): UseApiBatchReturn<T>;
 
 /**
  * API State Composable
@@ -558,4 +574,4 @@ interface AuthEventPayload {
 type AuthMonitorFn = (type: AuthEventType, payload: AuthEventPayload) => void;
 declare function setAuthMonitor(fn: AuthMonitorFn): void;
 
-export { type ApiError, type ApiPluginOptions, type ApiRequestConfig, type ApiState, type AuthEventPayload, AuthEventType, type AuthMode, type AuthMonitorFn, type AuthTokens$1 as AuthTokens, type BatchProgress, type BatchResultItem, type SetDataInput, type UseApiBatchOptions, type UseApiBatchReturn, type UseApiOptions, type UseApiReturn, createApi, createApiClient, setAuthMonitor, setupInterceptors, tokenManager, useAbortController, useApi, useApiBatch, useApiConfig, useApiDelete, useApiGet, useApiPatch, useApiPost, useApiPut, useApiState };
+export { type ApiError, type ApiPluginOptions, type ApiRequestConfig, type ApiState, type AuthEventPayload, AuthEventType, type AuthMode, type AuthMonitorFn, type AuthTokens$1 as AuthTokens, type BatchProgress, type BatchRequestConfig, type BatchResultItem, type SetDataInput, type UseApiBatchOptions, type UseApiBatchReturn, type UseApiOptions, type UseApiReturn, createApi, createApiClient, setAuthMonitor, setupInterceptors, tokenManager, useAbortController, useApi, useApiBatch, useApiConfig, useApiDelete, useApiGet, useApiPatch, useApiPost, useApiPut, useApiState };

package/dist/index.d.ts

@@ -23,6 +23,12 @@ interface ApiRequestConfig<D = unknown> extends Omit<AxiosRequestConfig<D>, "dat
     authMode?: AuthMode;
     retry?: boolean | number;
     retryDelay?: number;
+    /**
+     * Retry only when the response status code is in this list.
+     * Default: [408, 429, 500, 502, 503, 504]
+     * Empty array = retry on any error (network errors included).
+     */
+    retryStatusCodes?: number[];
 }
 interface UseApiOptions<T = unknown, D = unknown> extends ApiRequestConfig<D> {
     immediate?: boolean;
@@ -86,6 +92,7 @@ interface ApiPluginOptions {
     globalOptions?: {
         retry?: number | boolean;
         retryDelay?: number;
+        retryStatusCodes?: number[];
         useGlobalAbort?: boolean;
     };
 }
@@ -94,6 +101,23 @@ interface AuthTokens$1 {
     refreshToken?: string;
     expiresIn?: number;
 }
+/**
+ * Per-request configuration for a single item in a batch operation.
+ * String items in the batch array are automatically normalized to this shape
+ * with method: 'GET' and no data/params/headers.
+ */
+interface BatchRequestConfig<D = unknown> {
+    /** The URL to request */
+    url: string;
+    /** HTTP method. Default: 'GET' */
+    method?: string;
+    /** Request body (for POST, PUT, PATCH) */
+    data?: D;
+    /** Query parameters */
+    params?: D;
+    /** Per-request headers that override global defaults for this request only */
+    headers?: Record<string, string>;
+}
 /**
  * Result of a single request in a batch operation
  */
@@ -110,6 +134,10 @@ interface BatchResultItem<T = unknown> {
     error: ApiError | null;
     /** HTTP status code */
     statusCode: number | null;
+    /** Full AxiosResponse (null if failed — headers, status, etc. accessible here) */
+    response: AxiosResponse<T> | null;
+    /** The original normalized request config that produced this result */
+    request: BatchRequestConfig;
 }
 /**
  * Progress information for batch operations
@@ -239,7 +267,9 @@ declare function useApiDelete<T = unknown>(url: MaybeRefOrGetter<string | undefi
  *
  * Features:
  * - Reactive loading, data, error, progress states
- * - Reactive urls support (MaybeRefOrGetter)
+ * - Reactive request list support (MaybeRefOrGetter)
+ * - Per-request method, data, params, headers configuration
+ * - Full backward compatibility — plain string arrays still work
  * - Error tolerance with `settled: true` (default)
  * - Concurrency limiting
  * - Abort support for all pending requests
@@ -249,43 +279,29 @@ declare function useApiDelete<T = unknown>(url: MaybeRefOrGetter<string | undefi
  *
  * @example
  * ```ts
- * // Basic usage - fetch multiple users
- * const { data, loading, progress, execute } = useApiBatch<User>([
- *   '/users/1',
- *   '/users/2',
- *   '/users/3'
- * ])
+ * // Basic usage — plain strings (backward compatible)
+ * const { data, execute } = useApiBatch(['/users/1', '/users/2'])
  *
- * await execute()
- * console.log(data.value) // BatchResultItem<User>[]
+ * // Per-request config — method, data, params, headers
+ * const { data } = useApiBatch([
+ *   { url: '/users', params: { page: 1 } },
+ *   { url: '/posts', method: 'POST', data: { title: 'New' } },
+ *   '/health',  // string and object can be mixed
+ * ])
  *
- * // With reactive urls
- * const userIds = ref([1, 2, 3])
- * const urls = computed(() => userIds.value.map(id => `/users/${id}`))
- * const { successfulData } = useApiBatch<User>(urls, { immediate: true })
+ * // Batch DELETE by IDs
+ * const ids = [1, 2, 3]
+ * useApiBatch(ids.map(id => ({ url: `/users/${id}`, method: 'DELETE' })))
  *
- * // With options
- * const { successfulData, errors, progress } = useApiBatch<Post>(
- *   ['/posts/1', '/posts/2', '/posts/3'],
- *   {
- *     concurrency: 2,        // Max 2 parallel requests
- *     immediate: true,       // Execute on mount
- *     onProgress: (p) => console.log(`${p.percentage}%`)
- *   }
+ * // Reactive getter with object configs
+ * const pages = ref([1, 2, 3])
+ * const { successfulData } = useApiBatch(
+ *   () => pages.value.map(page => ({ url: '/users', params: { page } })),
+ *   { watch: pages, immediate: true }
  * )
- *
- * // Strict mode - fail on first error
- * const { execute } = useApiBatch<User>(urls, { settled: false })
- *
- * // Auto re-execute when dependency changes
- * const filters = ref({ status: 'active' })
- * const { data } = useApiBatch<User>(urls, {
- *   watch: filters,
- *   immediate: true
- * })
  * ```
  */
-declare function useApiBatch<T = unknown>(urls: MaybeRefOrGetter<string[]>, options?: UseApiBatchOptions<T>): UseApiBatchReturn<T>;
+declare function useApiBatch<T = unknown>(requests: MaybeRefOrGetter<Array<string | BatchRequestConfig>>, options?: UseApiBatchOptions<T>): UseApiBatchReturn<T>;
 
 /**
  * API State Composable
@@ -558,4 +574,4 @@ interface AuthEventPayload {
 type AuthMonitorFn = (type: AuthEventType, payload: AuthEventPayload) => void;
 declare function setAuthMonitor(fn: AuthMonitorFn): void;
 
-export { type ApiError, type ApiPluginOptions, type ApiRequestConfig, type ApiState, type AuthEventPayload, AuthEventType, type AuthMode, type AuthMonitorFn, type AuthTokens$1 as AuthTokens, type BatchProgress, type BatchResultItem, type SetDataInput, type UseApiBatchOptions, type UseApiBatchReturn, type UseApiOptions, type UseApiReturn, createApi, createApiClient, setAuthMonitor, setupInterceptors, tokenManager, useAbortController, useApi, useApiBatch, useApiConfig, useApiDelete, useApiGet, useApiPatch, useApiPost, useApiPut, useApiState };
+export { type ApiError, type ApiPluginOptions, type ApiRequestConfig, type ApiState, type AuthEventPayload, AuthEventType, type AuthMode, type AuthMonitorFn, type AuthTokens$1 as AuthTokens, type BatchProgress, type BatchRequestConfig, type BatchResultItem, type SetDataInput, type UseApiBatchOptions, type UseApiBatchReturn, type UseApiOptions, type UseApiReturn, createApi, createApiClient, setAuthMonitor, setupInterceptors, tokenManager, useAbortController, useApi, useApiBatch, useApiConfig, useApiDelete, useApiGet, useApiPatch, useApiPost, useApiPut, useApiState };

package/dist/index.mjs

@@ -24,17 +24,34 @@ function useApiConfig() {
 }
 
 // src/utils/debounce.ts
+var DebounceCancelledError = class extends Error {
+  isDebounceCancelled = true;
+  constructor() {
+    super("Debounced call was superseded by a newer call");
+    this.name = "DebounceCancelledError";
+  }
+};
 function debounceFn(fn, delay) {
   let timeoutId = null;
+  let pendingReject = null;
   return function(...args) {
-    return new Promise((resolve) => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
+    if (pendingReject) {
+      pendingReject(new DebounceCancelledError());
+      pendingReject = null;
+    }
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    return new Promise((resolve, reject) => {
+      pendingReject = reject;
       timeoutId = setTimeout(async () => {
-        const result = await fn(...args);
-        resolve(result);
+        pendingReject = null;
         timeoutId = null;
+        try {
+          resolve(await fn(...args));
+        } catch (err) {
+          reject(err);
+        }
       }, delay);
     });
   };
@@ -145,6 +162,26 @@ function useAbortController() {
 }
 
 // src/useApi.ts
+var DEFAULT_RETRY_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+function cancellableSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve(true);
+      return;
+    }
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve(false);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      cleanup();
+      resolve(true);
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function useApi(url, options = {}) {
   const { axios: axios2, onError: globalErrorHandler, globalOptions, errorParser } = useApiConfig();
   const {
@@ -159,12 +196,14 @@ function useApi(url, options = {}) {
     skipErrorNotification = false,
     retry = globalOptions?.retry ?? false,
     retryDelay = globalOptions?.retryDelay ?? 1e3,
+    retryStatusCodes = globalOptions?.retryStatusCodes ?? DEFAULT_RETRY_STATUS_CODES,
     authMode = "default",
     useGlobalAbort = globalOptions?.useGlobalAbort ?? true,
     initialLoading = false,
     poll = 0,
     ...axiosConfig
   } = options;
+  const maxRetries = retry === false ? 0 : retry === true ? 3 : retry;
   const startLoading = initialLoading ?? immediate;
   const state = useApiState(initialData, { initialLoading: startLoading });
   const abortController2 = ref3(null);
@@ -204,28 +243,57 @@ function useApi(url, options = {}) {
     state.setLoading(true);
     state.setError(null);
     let wasCancelled = false;
+    let retryCount = 0;
     try {
+      if (!requestUrl) {
+        throw new Error("Request URL is missing");
+      }
       const rawData = config?.data !== void 0 ? config.data : axiosConfig.data;
       const resolvedData = toValue(rawData);
       const rawParams = config?.params !== void 0 ? config.params : axiosConfig.params;
       const resolvedParams = toValue(rawParams);
-      if (!requestUrl) {
-        throw new Error("Request URL is missing");
+      while (true) {
+        try {
+          const response = await axios2.request({
+            url: requestUrl,
+            method,
+            ...axiosConfig,
+            ...config,
+            data: resolvedData,
+            params: resolvedParams,
+            signal: controller.signal,
+            ...{ authMode: config?.authMode || authMode }
+          });
+          state.mutate(response.data, response);
+          state.setStatusCode(response.status);
+          onSuccess?.(response);
+          return response.data;
+        } catch (err) {
+          if (controller.signal.aborted || isAxiosError2(err) && err.code === "ERR_CANCELED") {
+            wasCancelled = true;
+            return null;
+          }
+          const apiError = errorParser ? errorParser(err) : parseApiError(err);
+          const canRetry = retryCount < maxRetries && (retryStatusCodes.length === 0 || retryStatusCodes.includes(apiError.status));
+          if (canRetry) {
+            retryCount++;
+            const aborted = await cancellableSleep(retryDelay, controller.signal);
+            if (aborted) {
+              wasCancelled = true;
+              state.setLoading(false);
+              return null;
+            }
+            continue;
+          }
+          if (!skipErrorNotification && globalErrorHandler) {
+            globalErrorHandler(apiError, err);
+          }
+          state.setError(apiError);
+          state.setStatusCode(apiError.status);
+          onError?.(apiError);
+          return null;
+        }
       }
-      const response = await axios2.request({
-        url: requestUrl,
-        method,
-        ...axiosConfig,
-        ...config,
-        data: resolvedData,
-        params: resolvedParams,
-        signal: controller.signal,
-        ...{ authMode: config?.authMode || authMode }
-      });
-      state.mutate(response.data, response);
-      state.setStatusCode(response.status);
-      onSuccess?.(response);
-      return response.data;
     } catch (err) {
       if (controller.signal.aborted || isAxiosError2(err) && err.code === "ERR_CANCELED") {
         wasCancelled = true;
@@ -260,7 +328,11 @@ function useApi(url, options = {}) {
       }
     }
   };
-  const execute = debounce > 0 ? debounceFn(executeRequest, debounce) : executeRequest;
+  const _debounced = debounce > 0 ? debounceFn(executeRequest, debounce) : null;
+  const execute = _debounced ? (config) => _debounced(config).catch((err) => {
+    if (err instanceof DebounceCancelledError) return null;
+    throw err;
+  }) : executeRequest;
   const abort = (msg) => {
     if (pollTimer) clearTimeout(pollTimer);
     abortController2.value?.abort(msg);
@@ -331,8 +403,12 @@ function useApiDelete(url, options) {
 }
 
 // src/useApiBatch.ts
-import { ref as ref4, computed, getCurrentScope as getCurrentScope2, onScopeDispose as onScopeDispose2, toValue as toValue2, watch as watch2 } from "vue";
-function useApiBatch(urls, options = {}) {
+import { ref as ref4, computed, effectScope, getCurrentScope as getCurrentScope2, onScopeDispose as onScopeDispose2, toValue as toValue2, watch as watch2 } from "vue";
+function normalizeRequest(item) {
+  if (typeof item === "string") return { url: item, method: "GET" };
+  return { method: "GET", ...item };
+}
+function useApiBatch(requests, options = {}) {
   const {
     settled = true,
     concurrency,
@@ -345,7 +421,7 @@ function useApiBatch(urls, options = {}) {
     onProgress,
     ...apiOptions
   } = options;
-  const getUrls = () => toValue2(urls);
+  const getRequests = () => toValue2(requests).map(normalizeRequest);
   const data = ref4([]);
   const loading = ref4(false);
   const error = ref4(null);
@@ -363,43 +439,54 @@ function useApiBatch(urls, options = {}) {
   const abortControllers = ref4([]);
   let isAborted = false;
   const updateProgress = (succeeded, failed) => {
-    const currentUrls = getUrls();
+    const currentRequests = getRequests();
     const completed = succeeded + failed;
     const newProgress = {
       completed,
-      total: currentUrls.length,
-      percentage: currentUrls.length > 0 ? Math.round(completed / currentUrls.length * 100) : 0,
+      total: currentRequests.length,
+      percentage: currentRequests.length > 0 ? Math.round(completed / currentRequests.length * 100) : 0,
       succeeded,
       failed
     };
     progress.value = newProgress;
     onProgress?.(newProgress);
   };
-  const executeRequest = async (url, index, signal) => {
-    const { execute: execute2, error: reqError, statusCode } = useApi(url, {
+  const executeRequest = async (config, index, signal) => {
+    const scope = effectScope();
+    const api = scope.run(() => useApi(config.url, {
       ...apiOptions,
+      method: config.method,
+      data: config.data,
+      params: config.params,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ...config.headers && { headers: config.headers },
       useGlobalAbort: false,
       skipErrorNotification
-    });
+    }));
+    const { execute: execute2, error: reqError, statusCode, response } = api;
     try {
       const result = await execute2({ signal });
       if (signal.aborted) {
         return {
-          url,
+          url: config.url,
           index,
           success: false,
           data: null,
           error: { message: "Request aborted", status: 0, code: "ABORTED" },
-          statusCode: null
+          statusCode: null,
+          response: null,
+          request: config
         };
       }
       const item = {
-        url,
+        url: config.url,
         index,
         success: result !== null && result !== void 0,
         data: result ?? null,
         error: reqError.value,
-        statusCode: statusCode.value
+        statusCode: statusCode.value,
+        response: response.value,
+        request: config
       };
       if (item.success) {
         onItemSuccess?.(item, index);
@@ -414,26 +501,30 @@ function useApiBatch(urls, options = {}) {
         code: "BATCH_ERROR"
       };
       const item = {
-        url,
+        url: config.url,
         index,
         success: false,
         data: null,
         error: apiError,
-        statusCode: null
+        statusCode: null,
+        response: null,
+        request: config
       };
       onItemError?.(item, index);
       return item;
+    } finally {
+      scope.stop();
     }
   };
-  const executeWithConcurrency = async (urls2, limit) => {
-    const results = new Array(urls2.length);
+  const executeWithConcurrency = async (requests2, limit) => {
+    const results = new Array(requests2.length);
     let succeededCount = 0;
     let failedCount = 0;
-    if (!limit || limit >= urls2.length) {
-      const promises = urls2.map((url, index) => {
+    if (!limit || limit >= requests2.length) {
+      const promises = requests2.map((config, index) => {
         const controller = new AbortController();
         abortControllers.value.push(controller);
-        return executeRequest(url, index, controller.signal).then((result) => {
+        return executeRequest(config, index, controller.signal).then((result) => {
           results[index] = result;
           if (result.success) {
             succeededCount++;
@@ -458,12 +549,12 @@ function useApiBatch(urls, options = {}) {
     } else {
       let currentIndex = 0;
       const executeNext = async () => {
-        while (currentIndex < urls2.length && !isAborted) {
+        while (currentIndex < requests2.length && !isAborted) {
           const index = currentIndex++;
-          const url = urls2[index];
+          const config = requests2[index];
           const controller = new AbortController();
           abortControllers.value.push(controller);
-          const result = await executeRequest(url, index, controller.signal);
+          const result = await executeRequest(config, index, controller.signal);
           results[index] = result;
           if (result.success) {
             succeededCount++;
@@ -480,7 +571,7 @@ function useApiBatch(urls, options = {}) {
           }
         }
       };
-      const workers = Array.from({ length: Math.min(limit, urls2.length) }, () => executeNext());
+      const workers = Array.from({ length: Math.min(limit, requests2.length) }, () => executeNext());
       if (settled) {
         await Promise.allSettled(workers);
       } else {
@@ -490,7 +581,7 @@ function useApiBatch(urls, options = {}) {
     return results;
   };
   const execute = async () => {
-    const currentUrls = getUrls();
+    const currentRequests = getRequests();
     isAborted = false;
     loading.value = true;
     error.value = null;
@@ -499,7 +590,7 @@ function useApiBatch(urls, options = {}) {
     abortControllers.value = [];
     updateProgress(0, 0);
     try {
-      const results = await executeWithConcurrency(currentUrls, concurrency);
+      const results = await executeWithConcurrency(currentRequests, concurrency);
       data.value = results;
       const allFailed = results.every((r) => !r.success);
       if (allFailed && results.length > 0) {
@@ -536,7 +627,7 @@ function useApiBatch(urls, options = {}) {
     data.value = [];
     progress.value = {
       completed: 0,
-      total: getUrls().length,
+      total: getRequests().length,
       percentage: 0,
       succeeded: 0,
       failed: 0
@@ -728,16 +819,16 @@ var tokenManager = new TokenManager();
 // src/features/interceptors.ts
 var AUTH_HEADER = "Authorization";
 var TOKEN_TYPE2 = "Bearer";
-var failedQueue = [];
-var isRefreshing = false;
-function processQueue(error, token = null) {
-  failedQueue.forEach((promise) => {
-    if (error) promise.reject(error);
-    else if (token) promise.resolve(token);
-  });
-  failedQueue = [];
-}
 function setupInterceptors(axiosInstance, options = {}) {
+  let failedQueue = [];
+  let isRefreshing = false;
+  function processQueue(error, token = null) {
+    failedQueue.forEach((promise) => {
+      if (error) promise.reject(error);
+      else if (token) promise.resolve(token);
+    });
+    failedQueue = [];
+  }
   const {
     refreshUrl = "/auth/refresh",
     refreshWithCredentials = false,

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@ametie/vue-muza-use",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Powerful Vue 3 API composable (Muza Kit) with Axios, Auto-Refresh & TypeScript",
   "author": "MortyQ",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/MortyQ/vue-useApi.git"
+    "url": "https://github.com/MortyQ/vue-useApi",
+    "directory": "packages/use-api"
   },
   "files": [
     "dist",