@trii/components 2.0.102 → 2.0.104

package/async-state/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@trii/components-async-state",
+  "private": true,
+  "description": "Stub de resolucion para el subpath @trii/components/async-state. No se publica como paquete propio: existe para que Node/webpack/TS con moduleResolution 'node' encuentren la entrada secundaria sin pasar por el campo 'exports'.",
+  "main": "../dist/cjs/async-state.js",
+  "module": "../dist/esm/async-state.js",
+  "types": "../dist/async-state.d.ts",
+  "sideEffects": false
+}

package/dist/async-state.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Modelo canónico de estado asíncrono (loading / error / caché remota).
+ *
+ * Unifica cómo los paneles representan el ciclo de vida de un dato remoto:
+ *
+ * - `idle`/`loading` sin datos  → carga inicial (bloqueante: skeleton/spinner).
+ * - `loading` con datos         → revalidación NO bloqueante (`isRevalidating`).
+ * - `rejected` con datos        → error manteniendo datos previos + retry.
+ * - `rejected` sin datos        → error bloqueante con retry.
+ * - `succeeded` sin datos       → estado realmente vacío (`isEmpty`).
+ *
+ * Los literales de `AsyncStatus` coinciden con el `RequestStatus` que usan los
+ * slices de los frontends Trii, para que sean compatibles sin conversión.
+ *
+ * Módulo puro: sin React, sin MUI, sin Redux, sin dominio. Se publica también
+ * por el subpath `@trii/components/async-state` para que un slice pueda
+ * consumirlo sin arrastrar la UI del paquete.
+ *
+ * Guía de uso: docs/ASYNC_STATE.md
+ */
+type AsyncStatus = 'idle' | 'loading' | 'succeeded' | 'rejected';
+/**
+ * Estado "crudo" persistible: es lo que guarda un slice de Redux o el estado
+ * interno de `useAsyncData`. Los flags derivados se calculan con
+ * `deriveAsyncState` (nunca se almacenan, para evitar inconsistencias).
+ */
+interface AsyncData<T> {
+    status: AsyncStatus;
+    /** Últimos datos válidos. Se preservan durante refetches y errores. */
+    data: T | undefined;
+    /** Mensaje del último error (null si la última operación fue exitosa). */
+    error: string | null;
+    /** Timestamp (Date.now()) del último fetch exitoso. Base para staleness. */
+    updatedAt: number | null;
+}
+/** Estado derivado listo para consumir desde la UI. */
+interface AsyncState<T> extends AsyncData<T> {
+    /** true si hay datos utilizables para mostrar (no undefined ni "vacíos"). */
+    hasData: boolean;
+    /** Carga inicial: está cargando y NO hay datos que mostrar → bloqueante. */
+    isInitialLoading: boolean;
+    /** Revalidación: está cargando y SÍ hay datos → no bloquear la UI. */
+    isRevalidating: boolean;
+    /** Vacío real: la última carga fue exitosa y no hay datos que mostrar. */
+    isEmpty: boolean;
+}
+/** Decide si un dato cuenta como "vacío" (p.ej. lista sin elementos). */
+type IsEmptyFn<T> = (data: T) => boolean;
+/**
+ * Vacío por defecto: `null`/`undefined` y arrays sin elementos.
+ * Cada feature puede aportar su propia regla (p.ej. "objeto sin campos").
+ */
+declare const defaultIsEmpty: <T>(data: T) => boolean;
+/** Estado inicial: nunca se hizo un fetch. */
+declare const asyncIdle: <T>() => AsyncData<T>;
+/**
+ * Transición a "request en curso".
+ * Por defecto preserva los datos previos (refetch no bloqueante).
+ * Pasar `clearData: true` solo cuando los datos viejos dejarían de ser
+ * válidos para la nueva request (p.ej. cambio de contacto seleccionado).
+ */
+declare const asyncRequestStarted: <T>(prev: AsyncData<T>, options?: {
+    clearData?: boolean;
+}) => AsyncData<T>;
+/** Transición a éxito: guarda datos, limpia error y sella `updatedAt`. */
+declare const asyncRequestSucceeded: <T>(data: T) => AsyncData<T>;
+/**
+ * Transición a error: guarda el mensaje y PRESERVA los datos previos
+ * para que la UI pueda seguir mostrándolos (error con datos).
+ */
+declare const asyncRequestFailed: <T>(error: string, prev: AsyncData<T>) => AsyncData<T>;
+/**
+ * Deriva los flags de UI a partir del estado crudo. Es la ÚNICA fuente de
+ * verdad para interpretar un estado asíncrono: la usan `useAsyncData`,
+ * los selectores de Redux y `<AsyncContent>`.
+ *
+ * Uso con un slice existente (sin reescribirlo):
+ *
+ * ```ts
+ * const selectChannelsAsyncState = createSelector(
+ *   selectChannelsState,
+ *   (state) =>
+ *     deriveAsyncState({
+ *       status: state.status.fetch,
+ *       data: state.channels,
+ *       error: state.error,
+ *     })
+ * );
+ * ```
+ */
+declare const deriveAsyncState: <T>(input: {
+    status: AsyncStatus;
+    data: T | undefined;
+    error?: string | null;
+    updatedAt?: number | null;
+    isEmpty?: IsEmptyFn<T>;
+}) => AsyncState<T>;
+/** true si el dato tiene más de `staleTime` ms (o nunca se cargó). */
+declare const isStale: (updatedAt: number | null, staleTime: number, now?: number) => boolean;
+
+/**
+ * Extrae un mensaje legible de cualquier error (axios, Error, string...).
+ *
+ * Orden de preferencia:
+ * 1. `error.response.data.message` / `error.response.data.error` (API Trii).
+ * 2. `error.message` (Error estándar, p.ej. "Network Error" de axios).
+ * 3. El string recibido tal cual.
+ * 4. `fallback`.
+ *
+ * No traduce: la traducción de mensajes genéricos ocurre en la UI
+ * (`<ErrorState>`); esto preserva el detalle técnico o del backend.
+ *
+ * Tipa axios por duck-typing a propósito: el módulo no importa axios, así que
+ * sirve igual con fetch o con cualquier cliente HTTP.
+ */
+declare const getErrorMessage: (error: unknown, fallback?: string) => string;
+
+/** Resultado de `useAsyncData`: estado derivado + acciones del ciclo de vida. */
+interface UseAsyncDataResult<T> extends AsyncState<T> {
+    /**
+     * Re-ejecuta el fetcher. Si ya hay datos, NO bloquea la UI
+     * (`isRevalidating` pasa a true y los datos siguen visibles).
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Alias semántico de `refetch` para los estados de error.
+     * Es el callback que debe recibir `<AsyncContent onRetry={...}>`.
+     */
+    retry: () => Promise<void>;
+    /** Vuelve al estado `idle` y cancela cualquier request en curso. */
+    reset: () => void;
+}
+
+/**
+ * Ciclo de vida completo de un dato remoto LOCAL a un panel (sin Redux).
+ *
+ * Comportamiento:
+ * - Fetch al montar (configurable con `fetchOnMount`) y cuando cambian `deps`.
+ * - Carga inicial sin datos → `isInitialLoading` (bloqueante).
+ * - Refetch con datos → `isRevalidating`: los datos siguen visibles.
+ * - Error con datos previos → `status: 'rejected'` + datos preservados.
+ * - Error sin datos → `error` para mostrar un estado de error con `retry`.
+ * - `refetch()`/`retry()` re-ejecutan el fetcher; nunca bloquean si hay datos.
+ * - Cancelación automática (AbortSignal) y guarda de carrera: si se dispara
+ *   una request nueva, las respuestas viejas se descartan.
+ * - `autoRetry` opcional con backoff lineal antes de mostrar el error.
+ *
+ * Usar Redux en su lugar cuando el dato se comparte entre varios paneles o
+ * se actualiza por socket (ver docs/ASYNC_STATE.md §¿Redux o hook?).
+ *
+ * @example
+ * const state = useAsyncData(
+ *   (signal) => reportsService.getReports(url, { signal }),
+ *   { deps: [url] }
+ * );
+ * return (
+ *   <AsyncContent state={state} onRetry={state.retry}>
+ *     {(reports) => <ReportList reports={reports} />}
+ *   </AsyncContent>
+ * );
+ */
+declare function useAsyncData<T>(fetcher: (signal: AbortSignal) => Promise<T>, options?: {
+    /** Regla de "vacío" del dato (default: null/undefined o array vacío). */
+    isEmpty?: IsEmptyFn<T>;
+    /** Disparar el fetch al montar y al cambiar `deps` (default: true). */
+    fetchOnMount?: boolean;
+    /**
+     * Preservar datos previos durante refetches (default: true).
+     * Poner en false solo si los datos viejos serían inválidos/engañosos.
+     */
+    keepPreviousData?: boolean;
+    /**
+     * Reintentos automáticos antes de marcar error (default: sin reintentos;
+     * el usuario decide con el botón de retry).
+     */
+    autoRetry?: {
+        attempts: number;
+        delayMs?: number;
+    };
+    /** Dependencias que re-disparan el fetch (p.ej. un id o filtro). */
+    deps?: ReadonlyArray<unknown>;
+}): UseAsyncDataResult<T>;
+
+export { type AsyncData, type AsyncState, type AsyncStatus, type IsEmptyFn, type UseAsyncDataResult, asyncIdle, asyncRequestFailed, asyncRequestStarted, asyncRequestSucceeded, defaultIsEmpty, deriveAsyncState, getErrorMessage, isStale, useAsyncData };

package/dist/cjs/async-state.js

@@ -0,0 +1,2 @@
+"use strict";var s=require("react");const v=e=>e==null?!0:Array.isArray(e)?e.length===0:!1,A=()=>({status:"idle",data:void 0,error:null,updatedAt:null}),D=(e,t)=>({status:"loading",data:t?.clearData?void 0:e.data,error:null,updatedAt:e.updatedAt}),E=e=>({status:"succeeded",data:e,error:null,updatedAt:Date.now()}),S=(e,t)=>({status:"rejected",data:t.data,error:e,updatedAt:t.updatedAt}),q=e=>{const{status:t,data:r,error:a=null,updatedAt:o=null}=e,l=e.isEmpty??v,n=r!==void 0&&!l(r),i=t==="loading";return{status:t,data:r,error:a,updatedAt:o,hasData:n,isInitialLoading:i&&!n,isRevalidating:i&&n,isEmpty:t==="succeeded"&&!n}},C=(e,t,r=Date.now())=>e===null||r-e>t,w=(e,t="Unknown error")=>{if(typeof e=="string"&&e.length>0)return e;if(e!==null&&typeof e=="object"){const r=e,a=r.response?.data?.message??r.response?.data?.error;if(typeof a=="string"&&a.length>0)return a;if(typeof r.message=="string"&&r.message.length>0)return r.message}return t},j=e=>new Promise(t=>setTimeout(t,e));function x(e,t={}){const{isEmpty:r,fetchOnMount:a=!0,keepPreviousData:o=!0,autoRetry:l,deps:n=[]}=t,[i,y]=s.useState(()=>A()),b=s.useRef(e);b.current=e;const u=s.useRef(0),f=s.useRef(null),R=l?.attempts??0,h=l?.delayMs??500,g=s.useCallback(async()=>{const p=++u.current;f.current?.abort();const c=new AbortController;f.current=c,y(d=>D(d,{clearData:!o}));const I=Math.max(0,R);for(let d=0;;d+=1)try{const m=await b.current(c.signal);if(p!==u.current||c.signal.aborted)return;y(E(m));return}catch(m){if(p!==u.current||c.signal.aborted)return;if(d<I){if(await j(h*(d+1)),p!==u.current||c.signal.aborted)return;continue}y(k=>S(w(m),k));return}},[o,R,h]);s.useEffect(()=>(a&&g(),()=>{u.current+=1,f.current?.abort()}),[a,g,...n]);const M=s.useCallback(()=>{u.current+=1,f.current?.abort(),y(A())},[]);return{...q({...i,isEmpty:r}),refetch:g,retry:g,reset:M}}exports.asyncIdle=A,exports.asyncRequestFailed=S,exports.asyncRequestStarted=D,exports.asyncRequestSucceeded=E,exports.defaultIsEmpty=v,exports.deriveAsyncState=q,exports.getErrorMessage=w,exports.isStale=C,exports.useAsyncData=x;
+//# sourceMappingURL=async-state.js.map

package/dist/cjs/async-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-state.js","sources":["../../src/asyncState/asyncState.ts","../../src/asyncState/getErrorMessage.ts","../../src/asyncState/useAsyncData.ts"],"sourcesContent":["/**\n * Modelo canónico de estado asíncrono (loading / error / caché remota).\n *\n * Unifica cómo los paneles representan el ciclo de vida de un dato remoto:\n *\n * - `idle`/`loading` sin datos  → carga inicial (bloqueante: skeleton/spinner).\n * - `loading` con datos         → revalidación NO bloqueante (`isRevalidating`).\n * - `rejected` con datos        → error manteniendo datos previos + retry.\n * - `rejected` sin datos        → error bloqueante con retry.\n * - `succeeded` sin datos       → estado realmente vacío (`isEmpty`).\n *\n * Los literales de `AsyncStatus` coinciden con el `RequestStatus` que usan los\n * slices de los frontends Trii, para que sean compatibles sin conversión.\n *\n * Módulo puro: sin React, sin MUI, sin Redux, sin dominio. Se publica también\n * por el subpath `@trii/components/async-state` para que un slice pueda\n * consumirlo sin arrastrar la UI del paquete.\n *\n * Guía de uso: docs/ASYNC_STATE.md\n */\n\nexport type AsyncStatus = 'idle' | 'loading' | 'succeeded' | 'rejected';\n\n/**\n * Estado \"crudo\" persistible: es lo que guarda un slice de Redux o el estado\n * interno de `useAsyncData`. Los flags derivados se calculan con\n * `deriveAsyncState` (nunca se almacenan, para evitar inconsistencias).\n */\nexport interface AsyncData<T> {\n  status: AsyncStatus;\n  /** Últimos datos válidos. Se preservan durante refetches y errores. */\n  data: T | undefined;\n  /** Mensaje del último error (null si la última operación fue exitosa). */\n  error: string | null;\n  /** Timestamp (Date.now()) del último fetch exitoso. Base para staleness. */\n  updatedAt: number | null;\n}\n\n/** Estado derivado listo para consumir desde la UI. */\nexport interface AsyncState<T> extends AsyncData<T> {\n  /** true si hay datos utilizables para mostrar (no undefined ni \"vacíos\"). */\n  hasData: boolean;\n  /** Carga inicial: está cargando y NO hay datos que mostrar → bloqueante. */\n  isInitialLoading: boolean;\n  /** Revalidación: está cargando y SÍ hay datos → no bloquear la UI. */\n  isRevalidating: boolean;\n  /** Vacío real: la última carga fue exitosa y no hay datos que mostrar. */\n  isEmpty: boolean;\n}\n\n/** Decide si un dato cuenta como \"vacío\" (p.ej. lista sin elementos). */\nexport type IsEmptyFn<T> = (data: T) => boolean;\n\n/**\n * Vacío por defecto: `null`/`undefined` y arrays sin elementos.\n * Cada feature puede aportar su propia regla (p.ej. \"objeto sin campos\").\n */\nexport const defaultIsEmpty = <T>(data: T): boolean => {\n  if (data === null || data === undefined) return true;\n  if (Array.isArray(data)) return data.length === 0;\n  return false;\n};\n\n/** Estado inicial: nunca se hizo un fetch. */\nexport const asyncIdle = <T>(): AsyncData<T> => ({\n  status: 'idle',\n  data: undefined,\n  error: null,\n  updatedAt: null,\n});\n\n/**\n * Transición a \"request en curso\".\n * Por defecto preserva los datos previos (refetch no bloqueante).\n * Pasar `clearData: true` solo cuando los datos viejos dejarían de ser\n * válidos para la nueva request (p.ej. cambio de contacto seleccionado).\n */\nexport const asyncRequestStarted = <T>(\n  prev: AsyncData<T>,\n  options?: { clearData?: boolean }\n): AsyncData<T> => ({\n  status: 'loading',\n  data: options?.clearData ? undefined : prev.data,\n  error: null,\n  updatedAt: prev.updatedAt,\n});\n\n/** Transición a éxito: guarda datos, limpia error y sella `updatedAt`. */\nexport const asyncRequestSucceeded = <T>(data: T): AsyncData<T> => ({\n  status: 'succeeded',\n  data,\n  error: null,\n  updatedAt: Date.now(),\n});\n\n/**\n * Transición a error: guarda el mensaje y PRESERVA los datos previos\n * para que la UI pueda seguir mostrándolos (error con datos).\n */\nexport const asyncRequestFailed = <T>(\n  error: string,\n  prev: AsyncData<T>\n): AsyncData<T> => ({\n  status: 'rejected',\n  data: prev.data,\n  error,\n  updatedAt: prev.updatedAt,\n});\n\n/**\n * Deriva los flags de UI a partir del estado crudo. Es la ÚNICA fuente de\n * verdad para interpretar un estado asíncrono: la usan `useAsyncData`,\n * los selectores de Redux y `<AsyncContent>`.\n *\n * Uso con un slice existente (sin reescribirlo):\n *\n * ```ts\n * const selectChannelsAsyncState = createSelector(\n *   selectChannelsState,\n *   (state) =>\n *     deriveAsyncState({\n *       status: state.status.fetch,\n *       data: state.channels,\n *       error: state.error,\n *     })\n * );\n * ```\n */\nexport const deriveAsyncState = <T>(input: {\n  status: AsyncStatus;\n  data: T | undefined;\n  error?: string | null;\n  updatedAt?: number | null;\n  isEmpty?: IsEmptyFn<T>;\n}): AsyncState<T> => {\n  const { status, data, error = null, updatedAt = null } = input;\n  const isEmptyFn: IsEmptyFn<T> = input.isEmpty ?? defaultIsEmpty;\n\n  const hasData = data !== undefined && !isEmptyFn(data);\n  const isLoading = status === 'loading';\n\n  return {\n    status,\n    data,\n    error,\n    updatedAt,\n    hasData,\n    isInitialLoading: isLoading && !hasData,\n    isRevalidating: isLoading && hasData,\n    isEmpty: status === 'succeeded' && !hasData,\n  };\n};\n\n/** true si el dato tiene más de `staleTime` ms (o nunca se cargó). */\nexport const isStale = (\n  updatedAt: number | null,\n  staleTime: number,\n  now: number = Date.now()\n): boolean => updatedAt === null || now - updatedAt > staleTime;\n","/**\n * Extrae un mensaje legible de cualquier error (axios, Error, string...).\n *\n * Orden de preferencia:\n * 1. `error.response.data.message` / `error.response.data.error` (API Trii).\n * 2. `error.message` (Error estándar, p.ej. \"Network Error\" de axios).\n * 3. El string recibido tal cual.\n * 4. `fallback`.\n *\n * No traduce: la traducción de mensajes genéricos ocurre en la UI\n * (`<ErrorState>`); esto preserva el detalle técnico o del backend.\n *\n * Tipa axios por duck-typing a propósito: el módulo no importa axios, así que\n * sirve igual con fetch o con cualquier cliente HTTP.\n */\nexport const getErrorMessage = (\n  error: unknown,\n  fallback = 'Unknown error'\n): string => {\n  if (typeof error === 'string' && error.length > 0) return error;\n\n  if (error !== null && typeof error === 'object') {\n    const candidate = error as {\n      response?: { data?: { message?: unknown; error?: unknown } };\n      message?: unknown;\n    };\n\n    const apiMessage =\n      candidate.response?.data?.message ?? candidate.response?.data?.error;\n    if (typeof apiMessage === 'string' && apiMessage.length > 0) {\n      return apiMessage;\n    }\n\n    if (typeof candidate.message === 'string' && candidate.message.length > 0) {\n      return candidate.message;\n    }\n  }\n\n  return fallback;\n};\n","import { useCallback, useEffect, useRef, useState } from 'react';\nimport { UseAsyncDataResult } from './types';\nimport {\n  AsyncData,\n  IsEmptyFn,\n  asyncIdle,\n  asyncRequestFailed,\n  asyncRequestStarted,\n  asyncRequestSucceeded,\n  deriveAsyncState,\n} from './asyncState';\nimport { getErrorMessage } from './getErrorMessage';\n\nconst sleep = (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, ms));\n\n/**\n * Ciclo de vida completo de un dato remoto LOCAL a un panel (sin Redux).\n *\n * Comportamiento:\n * - Fetch al montar (configurable con `fetchOnMount`) y cuando cambian `deps`.\n * - Carga inicial sin datos → `isInitialLoading` (bloqueante).\n * - Refetch con datos → `isRevalidating`: los datos siguen visibles.\n * - Error con datos previos → `status: 'rejected'` + datos preservados.\n * - Error sin datos → `error` para mostrar un estado de error con `retry`.\n * - `refetch()`/`retry()` re-ejecutan el fetcher; nunca bloquean si hay datos.\n * - Cancelación automática (AbortSignal) y guarda de carrera: si se dispara\n *   una request nueva, las respuestas viejas se descartan.\n * - `autoRetry` opcional con backoff lineal antes de mostrar el error.\n *\n * Usar Redux en su lugar cuando el dato se comparte entre varios paneles o\n * se actualiza por socket (ver docs/ASYNC_STATE.md §¿Redux o hook?).\n *\n * @example\n * const state = useAsyncData(\n *   (signal) => reportsService.getReports(url, { signal }),\n *   { deps: [url] }\n * );\n * return (\n *   <AsyncContent state={state} onRetry={state.retry}>\n *     {(reports) => <ReportList reports={reports} />}\n *   </AsyncContent>\n * );\n */\nexport function useAsyncData<T>(\n  fetcher: (signal: AbortSignal) => Promise<T>,\n  options: {\n    /** Regla de \"vacío\" del dato (default: null/undefined o array vacío). */\n    isEmpty?: IsEmptyFn<T>;\n    /** Disparar el fetch al montar y al cambiar `deps` (default: true). */\n    fetchOnMount?: boolean;\n    /**\n     * Preservar datos previos durante refetches (default: true).\n     * Poner en false solo si los datos viejos serían inválidos/engañosos.\n     */\n    keepPreviousData?: boolean;\n    /**\n     * Reintentos automáticos antes de marcar error (default: sin reintentos;\n     * el usuario decide con el botón de retry).\n     */\n    autoRetry?: { attempts: number; delayMs?: number };\n    /** Dependencias que re-disparan el fetch (p.ej. un id o filtro). */\n    deps?: ReadonlyArray<unknown>;\n  } = {}\n): UseAsyncDataResult<T> {\n  const {\n    isEmpty,\n    fetchOnMount = true,\n    keepPreviousData = true,\n    autoRetry,\n    deps = [],\n  } = options;\n\n  const [state, setState] = useState<AsyncData<T>>(() => asyncIdle<T>());\n\n  // Refs: la última versión del fetcher y el control de carrera/cancelación.\n  // Guardar el fetcher en ref evita re-ejecutar el efecto cuando el caller\n  // pasa una arrow function inline (caso común).\n  const fetcherRef = useRef(fetcher);\n  fetcherRef.current = fetcher;\n  const requestIdRef = useRef(0);\n  const abortRef = useRef<AbortController | null>(null);\n\n  const autoRetryAttempts = autoRetry?.attempts ?? 0;\n  const autoRetryDelayMs = autoRetry?.delayMs ?? 500;\n\n  const execute = useCallback(async (): Promise<void> => {\n    const requestId = ++requestIdRef.current;\n    abortRef.current?.abort();\n    const controller = new AbortController();\n    abortRef.current = controller;\n\n    setState((prev) =>\n      asyncRequestStarted(prev, { clearData: !keepPreviousData })\n    );\n\n    const maxAttempts = Math.max(0, autoRetryAttempts);\n\n    for (let attempt = 0; ; attempt += 1) {\n      try {\n        const data = await fetcherRef.current(controller.signal);\n        // Respuesta vieja (hubo otra request después): se descarta.\n        if (requestId !== requestIdRef.current || controller.signal.aborted) {\n          return;\n        }\n        setState(asyncRequestSucceeded(data));\n        return;\n      } catch (error) {\n        // Cancelada por desmontaje o por una request nueva: no es un error.\n        if (requestId !== requestIdRef.current || controller.signal.aborted) {\n          return;\n        }\n        if (attempt < maxAttempts) {\n          // Backoff lineal: 1x, 2x, 3x... el delay base.\n          await sleep(autoRetryDelayMs * (attempt + 1));\n          if (requestId !== requestIdRef.current || controller.signal.aborted) {\n            return;\n          }\n          continue;\n        }\n        setState((prev) => asyncRequestFailed(getErrorMessage(error), prev));\n        return;\n      }\n    }\n  }, [keepPreviousData, autoRetryAttempts, autoRetryDelayMs]);\n\n  useEffect(() => {\n    if (fetchOnMount) {\n      // Fire-and-forget: el estado se actualiza vía setState dentro de execute.\n      execute();\n    }\n    return () => {\n      // Desmontaje o cambio de deps: cancela e invalida la request en curso.\n      requestIdRef.current += 1;\n      abortRef.current?.abort();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [fetchOnMount, execute, ...deps]);\n\n  const reset = useCallback((): void => {\n    requestIdRef.current += 1;\n    abortRef.current?.abort();\n    setState(asyncIdle<T>());\n  }, []);\n\n  const derived = deriveAsyncState({ ...state, isEmpty });\n\n  return { ...derived, refetch: execute, retry: execute, reset };\n}\n"],"names":["defaultIsEmpty","data","asyncIdle","asyncRequestStarted","prev","options","asyncRequestSucceeded","asyncRequestFailed","error","deriveAsyncState","input","status","updatedAt","isEmptyFn","hasData","isLoading","isStale","staleTime","now","getErrorMessage","fallback","candidate","apiMessage","sleep","ms","resolve","useAsyncData","fetcher","isEmpty","fetchOnMount","keepPreviousData","autoRetry","deps","state","setState","useState","fetcherRef","useRef","requestIdRef","abortRef","autoRetryAttempts","autoRetryDelayMs","execute","useCallback","requestId","controller","maxAttempts","attempt","useEffect","reset"],"mappings":"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"}