@vielzeug/fetchit 1.0.4 → 1.1.1

package/README.md

@@ -0,0 +1,511 @@
+# @vielzeug/fetchit
+
+Modern, type-safe HTTP client with intelligent caching, request deduplication, and query management for TypeScript.
+
+## Features
+
+- ✅ **Type-Safe** - Full TypeScript support with automatic type inference
+- ✅ **Zero Dependencies** - Only requires `@vielzeug/toolkit` for retry logic
+- ✅ **Lightweight** - ~3 KB gzipped
+- ✅ **Smart Caching** - TanStack Query-inspired caching with stale-while-revalidate
+- ✅ **Request Deduplication** - Prevents duplicate in-flight requests
+- ✅ **Async Validation** - Built-in retry logic with exponential backoff
+- ✅ **Abort Support** - Cancel requests with AbortController
+- ✅ **Framework Agnostic** - Works anywhere JavaScript runs
+- ✅ **Stable Keys** - Property order doesn't matter for cache matching
+
+## Installation
+
+```bash
+# pnpm
+pnpm add @vielzeug/fetchit
+
+# npm
+npm install @vielzeug/fetchit
+
+# yarn
+yarn add @vielzeug/fetchit
+```
+
+## Quick Start
+
+### Simple HTTP Client
+
+```typescript
+import { createHttpClient } from '@vielzeug/fetchit';
+
+const http = createHttpClient({
+  baseUrl: 'https://api.example.com',
+  timeout: 5000,
+  headers: { 'Authorization': 'Bearer token' }
+});
+
+// Make requests
+const user = await http.get('/users/1');
+const created = await http.post('/users', {
+  body: { name: 'Alice', email: 'alice@example.com' }
+});
+
+// Update headers dynamically
+http.setHeaders({ 'Authorization': 'Bearer new-token' });
+```
+
+### Query Client with Caching
+
+```typescript
+import { createQueryClient, createHttpClient } from '@vielzeug/fetchit';
+
+const http = createHttpClient({ baseUrl: 'https://api.example.com' });
+const queryClient = createQueryClient({
+  cache: { 
+    staleTime: 5000,  // 5 seconds
+    gcTime: 300000    // 5 minutes
+  }
+});
+
+// Fetch with caching
+const user = await queryClient.fetch({
+  queryKey: ['users', 1],
+  queryFn: () => http.get('/users/1'),
+  staleTime: 5000,
+  retry: 3
+});
+
+// Same request reuses cache
+const sameUser = await queryClient.fetch({
+  queryKey: ['users', 1],
+  queryFn: () => http.get('/users/1')
+}); // ✅ Returns cached data instantly
+```
+
+### Using Both Together
+
+```typescript
+import { createHttpClient, createQueryClient } from '@vielzeug/fetchit';
+
+// Create HTTP client for requests
+const http = createHttpClient({ 
+  baseUrl: 'https://api.example.com',
+  headers: { 'Authorization': 'Bearer token' }
+});
+
+// Create query client for caching
+const queryClient = createQueryClient({
+  cache: { staleTime: 5000 }
+});
+
+// Use HTTP client for simple requests
+await http.post('/analytics', { body: { event: 'click' } });
+
+// Use query client for cached data fetching
+await queryClient.fetch({
+  queryKey: ['users'],
+  queryFn: () => http.get('/users')
+});
+
+// Mutations with cache invalidation
+await queryClient.mutate({
+  mutationFn: (data) => http.post('/users', { body: data }),
+  onSuccess: () => queryClient.invalidate(['users'])
+}, { name: 'Charlie' });
+```
+
+## API Reference
+
+### HTTP Client
+
+#### `createHttpClient(options)`
+
+Creates a simple HTTP client for making requests without caching overhead.
+
+**Options:**
+- `baseUrl?: string` - Base URL for all requests
+- `headers?: Record<string, string>` - Default headers
+- `timeout?: number` - Request timeout in milliseconds (default: 30000)
+- `dedupe?: boolean` - Enable request deduplication (default: true)
+- `logger?: (level, msg, meta) => void` - Custom logger function
+
+**Methods:**
+- `get(url, config?)` - GET request
+- `post(url, config?)` - POST request
+- `put(url, config?)` - PUT request
+- `patch(url, config?)` - PATCH request
+- `delete(url, config?)` - DELETE request
+- `request(method, url, config?)` - Custom method
+- `setHeaders(headers)` - Update default headers
+- `getHeaders()` - Get current headers
+
+**Example:**
+```typescript
+const http = createHttpClient({
+  baseUrl: 'https://api.example.com',
+  timeout: 5000,
+  headers: { 'Authorization': 'Bearer token' }
+});
+
+// GET request
+const users = await http.get<User[]>('/users', {
+  params: { page: 1, limit: 10 }
+});
+
+// POST with body
+const created = await http.post<User>('/users', {
+  body: { name: 'Alice', email: 'alice@example.com' }
+});
+
+// Custom headers per request
+await http.get('/protected', {
+  headers: { 'X-Custom-Header': 'value' }
+});
+```
+
+---
+
+### Query Client
+
+#### `createQueryClient(options)`
+
+Creates a query client with intelligent caching and state management.
+
+**Options:**
+- `staleTime?: number` - Time in ms before data is considered stale (default: 0)
+- `gcTime?: number` - Time in ms before unused cache is garbage collected (default: 300000)
+- `cache?: { staleTime?, gcTime? }` - Nested cache configuration
+- `refetch?: { onFocus?, onReconnect? }` - Auto-refetch configuration
+
+**Methods:**
+- `fetch(options)` - Fetch data with caching
+- `prefetch(options)` - Prefetch data (swallows errors)
+- `mutate(options, variables)` - Execute mutations
+- `invalidate(queryKey)` - Invalidate cached queries
+- `setData(queryKey, data)` - Manually set cache data
+- `getData(queryKey)` - Get cached data
+- `getState(queryKey)` - Get query state
+- `subscribe(queryKey, listener)` - Subscribe to query changes
+- `unsubscribe(queryKey, listener)` - Unsubscribe from changes
+- `clearCache()` - Clear all cached data
+- `getCacheSize()` - Get number of cached entries
+
+**Example:**
+```typescript
+const queryClient = createQueryClient({
+  cache: { staleTime: 5000, gcTime: 300000 }
+});
+
+// Fetch with caching
+const user = await queryClient.fetch({
+  queryKey: ['users', 1],
+  queryFn: () => fetch('/users/1').then(r => r.json()),
+  staleTime: 5000,
+  retry: 3,
+  onSuccess: (data) => console.log('Loaded:', data),
+  onError: (err) => console.error('Failed:', err)
+});
+
+// Subscribe to changes
+const unsubscribe = queryClient.subscribe(['users', 1], (state) => {
+  console.log('State:', state.status, state.data);
+});
+
+// Manually update cache
+queryClient.setData(['users', 1], (old) => ({
+  ...old,
+  name: 'Updated Name'
+}));
+
+// Invalidate cache
+queryClient.invalidate(['users']); // Invalidates all user queries
+```
+
+---
+
+## Advanced Features
+
+### Request Deduplication
+
+Automatically prevents duplicate in-flight requests.
+
+```typescript
+const http = createHttpClient({ dedupe: true });
+
+// These run concurrently but only make ONE request
+const [user1, user2, user3] = await Promise.all([
+  http.get('/users/1'),
+  http.get('/users/1'),
+  http.get('/users/1')
+]);
+
+// All three get the same response
+console.log(user1 === user2 && user2 === user3); // true
+```
+
+### Retry Logic
+
+Built-in retry with exponential backoff.
+
+```typescript
+await queryClient.fetch({
+  queryKey: ['users'],
+  queryFn: () => fetchUsers(),
+  retry: 3, // Retry 3 times (4 attempts total)
+  retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 30000)
+});
+```
+
+### Abort Requests
+
+Cancel requests with AbortController.
+
+```typescript
+const controller = new AbortController();
+
+const promise = http.get('/slow-endpoint', {
+  signal: controller.signal
+});
+
+// Cancel after 1 second
+setTimeout(() => controller.abort(), 1000);
+
+try {
+  await promise;
+} catch (err) {
+  console.log('Request aborted');
+}
+```
+
+### Cache Invalidation
+
+Smart cache invalidation with prefix matching.
+
+```typescript
+// Cache some data
+await queryClient.fetch({
+  queryKey: ['users', 1],
+  queryFn: () => fetchUser(1)
+});
+
+await queryClient.fetch({
+  queryKey: ['users', 2],
+  queryFn: () => fetchUser(2)
+});
+
+// Invalidate all user queries
+queryClient.invalidate(['users']);
+
+// Or invalidate specific user
+queryClient.invalidate(['users', 1]);
+```
+
+### Stable Query Keys
+
+Property order doesn't matter for cache matching.
+
+```typescript
+// These are treated as the same query
+const key1 = ['users', { page: 1, filter: 'active' }];
+const key2 = ['users', { filter: 'active', page: 1 }];
+
+// Both use the same cache entry
+await queryClient.fetch({ queryKey: key1, queryFn: fetchUsers });
+await queryClient.fetch({ queryKey: key2, queryFn: fetchUsers }); // Uses cache
+```
+
+### Mutations
+
+Execute mutations with optimistic updates and cache invalidation.
+
+```typescript
+await queryClient.mutate({
+  mutationFn: async (data) => {
+    return await http.post('/users', { body: data });
+  },
+  onSuccess: (newUser, variables) => {
+    // Update cache optimistically
+    queryClient.setData(['users'], (old = []) => [...old, newUser]);
+  },
+  onError: (error, variables) => {
+    console.error('Mutation failed:', error);
+  },
+  onSettled: (data, error, variables) => {
+    // Refetch to ensure consistency
+    queryClient.invalidate(['users']);
+  }
+}, { name: 'Alice', email: 'alice@example.com' });
+```
+
+### Subscriptions
+
+Subscribe to query state changes.
+
+```typescript
+const unsubscribe = queryClient.subscribe(['users', 1], (state) => {
+  console.log('Status:', state.status);
+  console.log('Data:', state.data);
+  console.log('Error:', state.error);
+  console.log('Loading:', state.isLoading);
+  console.log('Success:', state.isSuccess);
+});
+
+// Later, unsubscribe
+unsubscribe();
+```
+
+---
+
+## TypeScript Support
+
+Full TypeScript support with automatic type inference.
+
+```typescript
+import { createHttpClient, type Infer } from '@vielzeug/fetchit';
+
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+const http = createHttpClient({ baseUrl: 'https://api.example.com' });
+
+// Type inference
+const user = await http.get<User>('/users/1');
+console.log(user.name); // ✅ Type-safe
+
+// Mutation types
+await queryClient.mutate<User, { name: string; email: string }>({
+  mutationFn: async (vars) => {
+    return await http.post<User>('/users', { body: vars });
+  },
+  onSuccess: (data) => {
+    console.log(data.id); // ✅ Type-safe
+  }
+}, { name: 'Alice', email: 'alice@example.com' });
+```
+
+---
+
+## Error Handling
+
+Custom error class with detailed information.
+
+```typescript
+import { HttpError } from '@vielzeug/fetchit';
+
+try {
+  await http.get('/not-found');
+} catch (err) {
+  if (err instanceof HttpError) {
+    console.log('URL:', err.url);          // '/not-found'
+    console.log('Method:', err.method);    // 'GET'
+    console.log('Status:', err.status);    // 404
+    console.log('Original:', err.original); // Original error
+  }
+}
+```
+
+---
+
+## Comparison with Alternatives
+
+| Feature | fetchit | TanStack Query | SWR | axios |
+|---------|---------|----------------|-----|-------|
+| Bundle Size | **~3 KB** | ~15 KB | ~5 KB | ~13 KB |
+| Dependencies | 1 (@vielzeug/toolkit) | 0 | 0 | Many |
+| TypeScript | Native | Native | Good | Good |
+| Caching | ✅ | ✅ | ✅ | ❌ |
+| Request Deduplication | ✅ | ✅ | ✅ | ❌ |
+| Stable Keys | ✅ | ❌ | ❌ | N/A |
+| Retry Logic | ✅ | ✅ | ✅ | ✅ |
+| Framework Agnostic | ✅ | ✅ | ❌ (React) | ✅ |
+| Separate HTTP Client | ✅ | ❌ | ❌ | ✅ |
+| Query Management | ✅ | ✅ | ✅ | ❌ |
+
+---
+
+## Best Practices
+
+### Use HTTP Client for Simple Requests
+
+When you don't need caching, use the HTTP client:
+
+```typescript
+const http = createHttpClient({ baseUrl: 'https://api.example.com' });
+
+// Simple one-off requests
+await http.post('/analytics/event', { body: { event: 'click' } });
+```
+
+### Use Query Client for Data Fetching
+
+When you need caching and state management:
+
+```typescript
+const queryClient = createQueryClient({ cache: { staleTime: 5000 } });
+const http = createHttpClient({ baseUrl: 'https://api.example.com' });
+
+// Fetch and cache user data
+await queryClient.fetch({
+  queryKey: ['users', userId],
+  queryFn: () => http.get(`/users/${userId}`)
+});
+```
+
+### Combine Both for Full-Featured Apps
+
+Use HTTP client and query client together:
+
+```typescript
+const http = createHttpClient({
+  baseUrl: 'https://api.example.com',
+  headers: { 'Authorization': 'Bearer token' }
+});
+
+const queryClient = createQueryClient({
+  cache: { staleTime: 5000 }
+});
+
+// HTTP client for simple requests
+await http.post('/events', { body: event });
+
+// Query client for cached data
+await queryClient.fetch({
+  queryKey: ['users'],
+  queryFn: () => http.get('/users')
+});
+
+// Mutations with cache invalidation
+await queryClient.mutate({
+  mutationFn: (data) => http.post('/users', { body: data }),
+  onSuccess: () => queryClient.invalidate(['users'])
+}, userData);
+```
+
+### Optimize Cache Settings
+
+```typescript
+const queryClient = createQueryClient({
+  cache: {
+    staleTime: 5000,    // 5 seconds - how long data is fresh
+    gcTime: 300000      // 5 minutes - how long to keep unused data
+  }
+});
+```
+
+---
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please read the [Contributing Guide](https://github.com/helmuthdu/vielzeug/blob/main/CONTRIBUTING.md).
+
+## Credits
+
+Inspired by [TanStack Query](https://tanstack.com/query) and [SWR](https://swr.vercel.app/).
+
+
+
+
+

package/dist/fetchit.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const y=require("./logit/dist/logit.cjs");class E extends Error{url;method;status;originalError;constructor(e,r,n,o,a){super(e),this.name="HttpError",this.url=r,this.method=n,this.status=o,this.originalError=a}}const C=5e3,R=12e4,S={ABORTED:499,BAD_REQUEST:400,CONFLICT:409,FORBIDDEN:403,NOT_ALLOWED:405,NOT_FOUND:404,PRE_CONDITION:412,TIMEOUT:408,UNAUTHORIZED:401},u={ERROR:"ERROR",PENDING:"PENDING",SUCCESS:"SUCCESS"},i=new Map;function T(t,e){if(e.id)return e.id;const{method:r="GET",body:n,headers:o}=e;return JSON.stringify({body:n,headers:o,method:r,url:t})}function f(t,e,r,n,o){const a=Date.now()-o,s=t.toLowerCase(),c=r.method?.toUpperCase()??"GET",l=b(e),p=t==="SUCCESS"?"✓":"✕";y.Logit[s](`HTTP::${c}(…/${l}) ${p} ${a}ms`,{req:r,res:n,url:e})}function b(t){return t.replace(/^https?:\/\/[^/]+\//,"")}async function h(t,e,{id:r,retries:n=2}){const o=Date.now(),a=e.method?.toUpperCase()??"GET";try{const s=await fetch(t,e),c=await O(s);return f("SUCCESS",t,e,c,o),d(r,u.SUCCESS),{data:c,ok:s.ok,status:s.status}}catch(s){if(f("ERROR",t,e,s,o),d(r,u.ERROR),n>0&&s instanceof TypeError)return h(t,e,{id:r,retries:n-1});throw new E(s instanceof Error?s.message:"Request failed",t,a,void 0,s)}finally{r&&e.method!=="GET"&&i.delete(r)}}async function O(t){if(t.status===204||t.headers.get("content-length")==="0")return;const e=t.headers.get("content-type")??"";return e.includes("application/json")?t.json():e.includes("text")?t.text():t.blob()}function d(t,e){const r=t?i.get(t):void 0;r&&(r.status=e)}async function m(t,e,r){const n=T(t,e);let o=i.get(n);if(o&&U(e,o)&&(o.controller.abort("Request aborted"),i.delete(n),o=void 0),o&&D(o))return o.request;const a=new AbortController,s=I(t,r),c=g(e,r,a),l=h(s,c,{id:n});return i.set(n,{controller:a,expiresIn:Date.now()+(r?.expiresIn??R),request:l,status:u.PENDING}),l}function U(t,e){return t.invalidate?!0:e?t.cancelable&&e.status===u.PENDING||e.status===u.ERROR:!1}function D(t){return Date.now()<=t.expiresIn}function I(t,e){if(!e?.url)return t;const r=e.url.replace(/\/+$/,""),n=t.replace(/^\/+/,"");return`${r}/${n}`}function N(t){return t instanceof FormData||t instanceof Blob||t instanceof ArrayBuffer||t instanceof URLSearchParams||typeof t=="string"}function g(t,e,r){const n=e?.timeout??C,o=AbortSignal.any([r.signal,AbortSignal.timeout(n)]);let a;const s={};return t.body!==void 0&&(N(t.body)?a=t.body:(a=JSON.stringify(t.body),s["Content-Type"]="application/json")),{...t,body:a,headers:j(e?.headers,t.headers,s),signal:o}}function w(t){const e={};if(t instanceof Headers)t.forEach((r,n)=>{e[n]=r});else if(Array.isArray(t))for(const[r,n]of t)e[r]=n;else for(const[r,n]of Object.entries(t))e[r]=n;return e}function j(t,e,r){const n={};if(t)for(const[o,a]of Object.entries(t))a!==void 0&&(n[o]=a);return e&&Object.assign(n,w(e)),r&&Object.assign(n,r),n}function A(t,e){if(!e||Object.keys(e).length===0)return t;const r=new URL(t);for(const[n,o]of Object.entries(e))o!==void 0&&r.searchParams.append(n,String(o));return r.toString()}function P(t={url:""}){const e=r=>(n,o={})=>m(n,{...o,method:r},t);return{cleanupCache(){const r=Date.now(),n=Array.from(i.entries()).filter(([,o])=>r>o.expiresIn).map(([o])=>o);for(const o of n)i.delete(o);return n.length},clearCache(){i.clear()},delete:e("DELETE"),get:e("GET"),getCacheSize(){return i.size},invalidateCache(r){return i.delete(r)},patch:e("PATCH"),post:e("POST"),put:e("PUT"),setHeaders(r){t.headers=Object.fromEntries(Object.entries({...t.headers,...r}).filter(([,n])=>n!==void 0))}}}exports.HttpError=E;exports.RequestErrorType=S;exports.RequestStatus=u;exports.buildUrl=A;exports.createHttpClient=P;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("./toolkit/dist/logit/dist/logit.cjs");const J=require("./toolkit/dist/async/retry.cjs"),V=0,Y=5*6e4,W=3e4,K=3,x=!0,v="application/json",z="content-type";class j extends Error{url;method;status;original;constructor(c,p,a,h,i){super(c),this.name="HttpError",this.url=p,this.method=a,this.status=h,this.original=i}}function _(t){return t instanceof Error?t:new Error(String(t))}function X(t,c,p){const a=(t||"").replace(/\/+$/,""),h=c.replace(/^\/+/,""),i=a?`${a}/${h}`:h;if(!p)return i;const m=Object.entries(p).filter(([,g])=>g!==void 0).map(([g,w])=>`${encodeURIComponent(g)}=${encodeURIComponent(String(w))}`).join("&");return m?`${i}${i.includes("?")?"&":"?"}${m}`:i}function Z(t){return typeof FormData<"u"&&t instanceof FormData||typeof Blob<"u"&&t instanceof Blob||typeof URLSearchParams<"u"&&t instanceof URLSearchParams||typeof t=="string"||t instanceof ArrayBuffer||t&&typeof t=="object"&&Object.prototype.toString.call(t)==="[object ArrayBuffer]"?!0:!!ArrayBuffer.isView?.(t)}function F(t){return t===null?"null":t===void 0?"undefined":typeof t!="object"?JSON.stringify(t):Array.isArray(t)?`[${t.map(a=>F(a)).join(",")}]`:`{${Object.keys(t).sort().map(a=>`${JSON.stringify(a)}:${F(t[a])}`).join(",")}}`}function tt(t){if(t==null)return"null";if(typeof FormData<"u"&&t instanceof FormData)return"[FormData]";if(typeof Blob<"u"&&t instanceof Blob)return`[Blob:${t.size}:${t.type}]`;if(typeof URLSearchParams<"u"&&t instanceof URLSearchParams)return`[URLSearchParams:${t.toString()}]`;if(t instanceof ArrayBuffer)return`[ArrayBuffer:${t.byteLength}]`;if(ArrayBuffer.isView?.(t))return`[ArrayBufferView:${t.byteLength}]`;if(typeof t=="string")return t;if(typeof t=="object")try{return F(t)}catch{return"[Object]"}try{return JSON.stringify(t)}catch{return"[Unknown]"}}function et(t,c){if(t===0||t===Number.POSITIVE_INFINITY){if(c)return{clear:()=>{},signal:c};const i=new AbortController;return{clear:()=>{},signal:i.signal}}if(typeof AbortSignal<"u"&&"timeout"in AbortSignal&&!c){const i=AbortSignal.timeout(t);return{clear:()=>{},signal:i}}const p=new AbortController,a=()=>p.abort();c&&(c.aborted?p.abort():c.addEventListener("abort",a,{once:!0}));const h=setTimeout(()=>p.abort(),t);return{clear:()=>{clearTimeout(h),c&&c.removeEventListener("abort",a)},signal:p.signal}}async function rt(t){if(t.status===204)return;const c=t.headers.get(z)??"";if(c.includes(v))return await t.json();if(c.startsWith("text/"))return await t.text();try{return await t.blob()}catch{return await t.text()}}function nt(t={}){const{baseUrl:c="",headers:p={},timeout:a=W,dedupe:h=x,logger:i}=t;let m={...p};const g=new Map;function w(f,d,C){i&&i(f,d,C)}async function A(f,d,C={}){const T=X(c,d,C.params),E=(f||"GET").toUpperCase(),{body:S,headers:R,dedupe:B,signal:N,...P}=C,$=B!==!1&&h,e=$?JSON.stringify({body:tt(S),full:T,m:E}):"";if($&&g.has(e))return g.get(e);const{signal:n,clear:r}=et(a,N??null),s={method:E,...P,headers:{...m,...R},signal:n};S!==void 0&&!Z(S)?(s.body=JSON.stringify(S),s.headers={[z]:v,...s.headers}):S!==void 0&&(s.body=S);const y=(async()=>{const l=Date.now();try{const u=await fetch(T,s),b=await rt(u);if(w("info",`${E} ${T} - ${u.status} (${Date.now()-l}ms)`,{req:s,res:b}),!u.ok)throw new j("Non-OK response",T,E,u.status,b);return b}catch(u){throw w("error",`${E} ${T} - ERROR`,u),u instanceof j?u:new j(_(u).message,T,E,void 0,u)}finally{r(),$&&g.delete(e)}})();return $&&g.set(e,y),y}return{delete:(f,d)=>A("DELETE",f,d),get:(f,d)=>A("GET",f,d),getHeaders:()=>({...m}),patch:(f,d)=>A("PATCH",f,d),post:(f,d)=>A("POST",f,d),put:(f,d)=>A("PUT",f,d),request:A,setHeaders(f){m=Object.fromEntries(Object.entries({...m,...f}).filter(([,d])=>d!==void 0))}}}function ot(t){const c=t?.cache?.staleTime??t?.staleTime??V,p=t?.cache?.gcTime??t?.gcTime??Y,a=new Map,h=new Map;function i(e){return F(e)}function m(e){const n=i(e);let r=a.get(n);return r||(r={abortController:null,data:void 0,dataUpdatedAt:0,error:null,errorUpdatedAt:0,fetchedAt:0,gcTimer:null,observers:new Set,promise:null,status:"idle"},a.set(n,r),h.set(n,n)),r}function g(e){const n={data:e.data,dataUpdatedAt:e.dataUpdatedAt,error:e.error,errorUpdatedAt:e.errorUpdatedAt,fetchedAt:e.fetchedAt,isError:e.status==="error",isIdle:e.status==="idle",isLoading:e.status==="pending",isSuccess:e.status==="success",status:e.status};e.observers.forEach(r=>{try{r(n)}catch{}})}function w(e,n,r){n.gcTimer&&(clearTimeout(n.gcTimer),n.gcTimer=null),r>0&&(n.gcTimer=setTimeout(()=>{a.delete(e),h.delete(e)},r))}function A(e){e.abortController?.abort(),e.gcTimer&&(clearTimeout(e.gcTimer),e.gcTimer=null)}function f(e,n,r=K){const s=e===!1?1:(e??r)+1;let y,l;return typeof n=="function"?(y=void 0,l=u=>n(u-1)):typeof n=="number"?(y=n,l=void 0):(y=1e3,l=(u,b)=>Math.min(b*2,3e4)),{backoff:l,delay:y,times:s}}async function d(e){const{queryKey:n,queryFn:r,staleTime:s=c,gcTime:y=p,enabled:l=!0,retry:u=K,retryDelay:b,onSuccess:L,onError:I}=e;if(!l)throw new Error("Query disabled");const H=i(n),o=m(n);if(o.status==="success"&&Date.now()-o.dataUpdatedAt<s)return o.data;if(o.promise)return o.promise;const U=new AbortController;o.abortController=U,o.status="pending",g(o);const{times:G,delay:M,backoff:Q}=f(u,b),k=(async()=>{try{const O=await J.retry(()=>r(),{backoff:Q,delay:M,signal:U.signal,times:G}),D=Date.now();o.data=O,o.status="success",o.dataUpdatedAt=D,o.fetchedAt=D,o.error=null,o.promise=null,o.abortController=null,w(H,o,y);try{L?.(O)}catch{}return g(o),O}catch(O){const D=_(O),q=U.signal.aborted||D.name==="AbortError";q?(o.status="idle",o.error=null):(o.status="error",o.error=D,o.errorUpdatedAt=Date.now()),o.promise=null,o.abortController=null;try{q||I?.(D)}catch{}throw g(o),D}})();return o.promise=k,k}async function C(e){return d({...e,enabled:!0}).catch(()=>{})}function T(e){const n=i(e),r=a.get(n);if(r){A(r),a.delete(n),h.delete(n);return}const s=[],y=n.slice(0,-1);for(const[l,u]of h.entries())if(u===n||u.startsWith(`${y},`)){const L=a.get(l);L&&A(L),s.push(l)}for(const l of s)a.delete(l),h.delete(l)}function E(){a.forEach(A),a.clear(),h.clear()}function S(e,n){const r=i(e),s=m(e);s.data=typeof n=="function"?n(s.data):n,s.dataUpdatedAt=Date.now(),s.fetchedAt=s.fetchedAt||Date.now(),s.status="success",w(r,s,p),g(s)}function R(e){const n=i(e);return a.get(n)?.data??void 0}function B(e){const n=i(e),r=a.get(n);return r?{data:r.data,dataUpdatedAt:r.dataUpdatedAt,error:r.error,errorUpdatedAt:r.errorUpdatedAt,fetchedAt:r.fetchedAt,isError:r.status==="error",isIdle:r.status==="idle",isLoading:r.status==="pending",isSuccess:r.status==="success",status:r.status}:null}function N(e,n){const r=m(e);r.observers.add(n);const s={data:r.data,dataUpdatedAt:r.dataUpdatedAt,error:r.error,errorUpdatedAt:r.errorUpdatedAt,fetchedAt:r.fetchedAt,isError:r.status==="error",isIdle:r.status==="idle",isLoading:r.status==="pending",isSuccess:r.status==="success",status:r.status};return n(s),()=>r.observers.delete(n)}function P(e,n){const r=i(e),s=a.get(r);s&&s.observers.delete(n)}async function $(e,n){const{mutationFn:r,onSuccess:s,onError:y,onSettled:l,retry:u=!1,retryDelay:b}=e,{times:L,delay:I,backoff:H}=f(u,b,0);try{const o=await J.retry(()=>r(n),{backoff:H,delay:I,times:L});try{s?.(o,n)}catch{}try{l?.(o,null,n)}catch{}return o}catch(o){const U=_(o);try{y?.(U,n)}catch{}try{l?.(void 0,U,n)}catch{}throw U}}return{clearCache:E,fetch:d,getCacheSize:()=>a.size,getData:R,getState:B,invalidate:T,mutate:$,prefetch:C,setData:S,subscribe:N,unsubscribe:P}}exports.HttpError=j;exports.createHttpClient=nt;exports.createQueryClient=ot;
 //# sourceMappingURL=fetchit.cjs.map