@structyl/api-client 1.0.0

package/dist/index.mjs

@@ -0,0 +1,887 @@
+import axios from 'axios';
+import { createContext, useContext, useRef, useCallback, useSyncExternalStore, useEffect, useState } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/client.ts
+var ApiClient = class {
+  constructor(config) {
+    this.config = config;
+    this.instance = axios.create({
+      baseURL: config.baseURL,
+      headers: config.headers,
+      timeout: config.timeout ?? 1e4
+    });
+    this.setupInterceptors();
+  }
+  setupInterceptors() {
+    this.instance.interceptors.request.use(async (requestConfig) => {
+      if (this.config.getAuthToken) {
+        const token = await this.config.getAuthToken();
+        if (token) {
+          requestConfig.headers.Authorization = `Bearer ${token}`;
+        }
+      }
+      return requestConfig;
+    });
+    this.instance.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const retriableConfig = error.config;
+        if (error.response?.status === 401 && this.config.refreshToken && retriableConfig && !retriableConfig._retried) {
+          retriableConfig._retried = true;
+          try {
+            const newToken = await this.config.refreshToken();
+            retriableConfig.headers["Authorization"] = `Bearer ${newToken}`;
+            return await this.instance.request(retriableConfig);
+          } catch (refreshErr) {
+            this.config.onRefreshError?.(refreshErr);
+          }
+        }
+        return Promise.reject(normalizeError(error));
+      }
+    );
+  }
+};
+function normalizeError(error) {
+  if (error.response) {
+    const responseData = error.response.data;
+    return {
+      status: error.response.status,
+      message: (typeof responseData?.["message"] === "string" ? responseData["message"] : null) ?? error.message,
+      data: error.response.data
+    };
+  }
+  return { status: 0, message: "No response received from server" };
+}
+function createApiClient(config) {
+  return new ApiClient(config);
+}
+
+// src/cache.ts
+function serializeKey(key) {
+  return JSON.stringify(key);
+}
+var QueryCache = class {
+  constructor(gcTime = 5 * 6e4) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.inFlight = /* @__PURE__ */ new Map();
+    // Discards responses from requests that were superseded (e.g. after cancelQueries)
+    this.generations = /* @__PURE__ */ new Map();
+    // Evicts entries when no subscriber remains for longer than gcTime
+    this.gcTimers = /* @__PURE__ */ new Map();
+    // AbortControllers for in-flight requests
+    this.abortControllers = /* @__PURE__ */ new Map();
+    // Global subscribers (for persistence and devtools)
+    this.globalSubscribers = /* @__PURE__ */ new Set();
+    this.gcTime = gcTime;
+  }
+  get(key) {
+    return this.entries.get(key);
+  }
+  subscribe(key, fn) {
+    const pending = this.gcTimers.get(key);
+    if (pending !== void 0) {
+      clearTimeout(pending);
+      this.gcTimers.delete(key);
+    }
+    if (!this.subscribers.has(key)) this.subscribers.set(key, /* @__PURE__ */ new Set());
+    this.subscribers.get(key).add(fn);
+    return () => {
+      const set = this.subscribers.get(key);
+      if (!set) return;
+      set.delete(fn);
+      if (set.size === 0) {
+        this.subscribers.delete(key);
+        const timer = setTimeout(() => {
+          this.entries.delete(key);
+          this.generations.delete(key);
+          this.gcTimers.delete(key);
+        }, this.gcTime);
+        this.gcTimers.set(key, timer);
+      }
+    };
+  }
+  subscribeGlobal(fn) {
+    this.globalSubscribers.add(fn);
+    return () => this.globalSubscribers.delete(fn);
+  }
+  notify(key) {
+    this.subscribers.get(key)?.forEach((fn) => fn());
+    this.globalSubscribers.forEach((fn) => fn());
+  }
+  setData(key, data, staleTime) {
+    this.entries.set(key, {
+      data,
+      error: void 0,
+      status: "success",
+      updatedAt: Date.now(),
+      staleTime
+    });
+    this.inFlight.delete(key);
+    this.notify(key);
+  }
+  setError(key, error) {
+    const existing = this.entries.get(key);
+    this.entries.set(key, {
+      data: existing?.data,
+      error,
+      status: "error",
+      updatedAt: Date.now(),
+      staleTime: 0
+    });
+    this.inFlight.delete(key);
+    this.notify(key);
+  }
+  setLoading(key) {
+    const existing = this.entries.get(key);
+    if (existing?.status === "loading") return;
+    this.entries.set(key, {
+      data: existing?.data,
+      error: void 0,
+      status: "loading",
+      updatedAt: existing?.updatedAt ?? 0,
+      staleTime: existing?.staleTime ?? 0
+    });
+    this.notify(key);
+  }
+  isStale(key) {
+    const e = this.entries.get(key);
+    if (!e || e.status === "idle" || e.status === "error") return true;
+    if (e.status === "loading") return false;
+    return e.updatedAt === 0 || Date.now() - e.updatedAt > e.staleTime;
+  }
+  // True only when markStale() was explicitly called on a successful entry.
+  // Used to detect *external* invalidation (e.g. after a mutation) vs time-based
+  // staleness, so the re-fetch effect doesn't loop when staleTime is 0.
+  isExternallyInvalidated(key) {
+    const e = this.entries.get(key);
+    return !!e && e.status === "success" && e.updatedAt === 0;
+  }
+  getInFlight(key) {
+    return this.inFlight.get(key);
+  }
+  setInFlight(key, p) {
+    this.inFlight.set(key, p);
+  }
+  clearInFlight(key) {
+    this.inFlight.delete(key);
+  }
+  // Returns the new generation. Does NOT touch inFlight — call clearInFlight separately.
+  bumpGeneration(key) {
+    const g = (this.generations.get(key) ?? 0) + 1;
+    this.generations.set(key, g);
+    return g;
+  }
+  getGeneration(key) {
+    return this.generations.get(key) ?? 0;
+  }
+  // Sets updatedAt = 0 as the sentinel for "externally invalidated"
+  markStale(key) {
+    const e = this.entries.get(key);
+    if (e) {
+      this.entries.set(key, { ...e, updatedAt: 0 });
+      this.notify(key);
+    }
+  }
+  // AbortController management
+  setAbortController(key, ctrl) {
+    this.abortControllers.set(key, ctrl);
+  }
+  getAbortController(key) {
+    return this.abortControllers.get(key);
+  }
+  clearAbortController(key) {
+    this.abortControllers.delete(key);
+  }
+  clear() {
+    for (const timer of this.gcTimers.values()) clearTimeout(timer);
+    this.gcTimers.clear();
+    for (const ctrl of this.abortControllers.values()) ctrl.abort();
+    this.abortControllers.clear();
+    this.entries.clear();
+    this.inFlight.clear();
+    this.generations.clear();
+    this.subscribers.clear();
+  }
+  snapshot() {
+    const result = {};
+    for (const [key, entry] of this.entries) {
+      if (entry.status === "success") result[key] = entry;
+    }
+    return result;
+  }
+  restore(state) {
+    for (const [key, entry] of Object.entries(state)) {
+      if (!this.entries.has(key)) this.entries.set(key, entry);
+    }
+  }
+};
+var QueryClient = class {
+  constructor(config) {
+    this.config = config ?? {};
+    this.cache = new QueryCache(config?.gcTime);
+  }
+  getQueryData(key) {
+    return this.cache.get(serializeKey(key))?.data;
+  }
+  setQueryData(key, updater) {
+    const k = serializeKey(key);
+    const existing = this.cache.get(k);
+    const newData = typeof updater === "function" ? updater(existing?.data) : updater;
+    this.cache.setData(k, newData, existing?.staleTime ?? 6e4);
+    this.config.onSuccess?.(newData, k);
+  }
+  invalidateQueries(options) {
+    this.cache.markStale(serializeKey(options.queryKey));
+  }
+  async cancelQueries(options) {
+    const k = serializeKey(options.queryKey);
+    this.cache.getAbortController(k)?.abort();
+    this.cache.clearAbortController(k);
+    this.cache.bumpGeneration(k);
+    this.cache.clearInFlight(k);
+    this.cache.markStale(k);
+  }
+  async prefetchQuery(options) {
+    const k = serializeKey(options.queryKey);
+    if (!this.cache.isStale(k)) return;
+    try {
+      const data = await options.queryFn();
+      this.cache.setData(k, data, options.staleTime ?? 6e4);
+      this.config.onSuccess?.(data, k);
+    } catch {
+    }
+  }
+  // Called internally after setData / setError to fire global callbacks
+  notifySuccess(data, key) {
+    this.config.onSuccess?.(data, key);
+  }
+  notifyError(error, key) {
+    this.config.onError?.(error, key);
+  }
+};
+var ApiContext = createContext(null);
+function useApiContext() {
+  const ctx = useContext(ApiContext);
+  if (!ctx) {
+    throw new Error(
+      "[api-client] Hooks must be used within <ApiProvider>. Wrap your app root with <ApiProvider client={api}>."
+    );
+  }
+  return ctx;
+}
+function useApiClient() {
+  return useApiContext().apiClient;
+}
+function makeQueryClient(config) {
+  return new QueryClient(config);
+}
+var browserQueryClient;
+function getQueryClient(config) {
+  if (typeof window === "undefined") return makeQueryClient(config);
+  if (!browserQueryClient) browserQueryClient = makeQueryClient(config);
+  return browserQueryClient;
+}
+function ApiProvider({
+  client,
+  children,
+  queryClient,
+  gcTime,
+  hydratedState,
+  queryClientConfig
+}) {
+  const qcRef = useRef(null);
+  if (!qcRef.current) {
+    const config = {
+      gcTime,
+      ...queryClientConfig
+    };
+    qcRef.current = queryClient ?? getQueryClient(config);
+    if (hydratedState) {
+      qcRef.current.cache.restore(hydratedState.entries);
+    }
+  }
+  const ctxRef = useRef(null);
+  if (!ctxRef.current || ctxRef.current.apiClient !== client) {
+    ctxRef.current = { apiClient: client, queryClient: qcRef.current };
+  }
+  return /* @__PURE__ */ jsx(ApiContext.Provider, { value: ctxRef.current, children });
+}
+ApiProvider.displayName = "ApiProvider";
+
+// src/utils.ts
+async function withRetry(fn, retries) {
+  let lastErr;
+  for (let i = 0; i <= retries; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i < retries) {
+        await new Promise(
+          (res) => setTimeout(res, Math.min(1e3 * 2 ** i, 3e4))
+        );
+      }
+    }
+  }
+  throw lastErr;
+}
+function toApiError(err) {
+  if (err != null && typeof err.status === "number" && typeof err.message === "string") {
+    return err;
+  }
+  return {
+    status: -1,
+    message: err instanceof Error ? err.message : String(err)
+  };
+}
+
+// src/hooks/useApiQuery.ts
+function useApiQuery(keyOrUrl, urlOrFnOrOptions, maybeOptions) {
+  const { apiClient, queryClient } = useApiContext();
+  let serializedKey;
+  let options;
+  const fetcherRef = useRef(null);
+  if (typeof urlOrFnOrOptions === "string") {
+    const url = urlOrFnOrOptions;
+    serializedKey = serializeKey(
+      typeof keyOrUrl === "string" ? [keyOrUrl] : keyOrUrl
+    );
+    fetcherRef.current = (signal) => apiClient.instance.get(url, { signal }).then((r) => r.data);
+    options = maybeOptions;
+  } else if (typeof urlOrFnOrOptions === "function") {
+    const fn = urlOrFnOrOptions;
+    serializedKey = serializeKey(
+      typeof keyOrUrl === "string" ? [keyOrUrl] : keyOrUrl
+    );
+    fetcherRef.current = (_signal) => fn(apiClient.instance);
+    options = maybeOptions;
+  } else {
+    const url = keyOrUrl;
+    serializedKey = serializeKey([url]);
+    fetcherRef.current = (signal) => apiClient.instance.get(url, { signal }).then((r) => r.data);
+    options = urlOrFnOrOptions;
+  }
+  const retries = options?.retry === false ? 0 : options?.retry ?? 1;
+  const staleTime = options?.staleTime ?? 6e4;
+  if (options?.initialData !== void 0 && !queryClient.cache.get(serializedKey)) {
+    queryClient.cache.setData(serializedKey, options.initialData, staleTime);
+  }
+  const previousDataRef = useRef(void 0);
+  const debounceTimerRef = useRef(void 0);
+  const doFetch = useCallback(
+    async (force = false) => {
+      if (!force && !queryClient.cache.isStale(serializedKey)) return;
+      if (queryClient.cache.getInFlight(serializedKey)) return;
+      const ctrl = new AbortController();
+      queryClient.cache.setAbortController(serializedKey, ctrl);
+      queryClient.cache.setLoading(serializedKey);
+      const gen = queryClient.cache.bumpGeneration(serializedKey);
+      const signal = ctrl.signal;
+      const promise = withRetry(() => fetcherRef.current(signal), retries);
+      queryClient.cache.setInFlight(serializedKey, promise);
+      try {
+        const data2 = await promise;
+        if (queryClient.cache.getGeneration(serializedKey) !== gen) return;
+        queryClient.cache.setData(serializedKey, data2, staleTime);
+        queryClient.notifySuccess(data2, serializedKey);
+        queryClient.cache.clearAbortController(serializedKey);
+      } catch (err) {
+        if (queryClient.cache.getGeneration(serializedKey) !== gen) return;
+        if (err instanceof Error && err.name === "CanceledError") return;
+        const apiError = toApiError(err);
+        queryClient.cache.setError(serializedKey, apiError);
+        queryClient.notifyError(apiError, serializedKey);
+        queryClient.cache.clearAbortController(serializedKey);
+      }
+    },
+    [serializedKey, staleTime, retries, queryClient]
+  );
+  const debouncedDoFetch = useCallback(
+    (force = false) => {
+      const debounceMs = options?.debounce;
+      if (debounceMs) {
+        if (debounceTimerRef.current !== void 0) {
+          clearTimeout(debounceTimerRef.current);
+        }
+        debounceTimerRef.current = setTimeout(() => {
+          debounceTimerRef.current = void 0;
+          void doFetch(force);
+        }, debounceMs);
+      } else {
+        void doFetch(force);
+      }
+    },
+    [doFetch, options?.debounce]
+  );
+  const entry = useSyncExternalStore(
+    (notify) => queryClient.cache.subscribe(serializedKey, notify),
+    () => queryClient.cache.get(serializedKey),
+    () => queryClient.cache.get(serializedKey)
+  );
+  useEffect(() => {
+    if (options?.enabled === false) return;
+    debouncedDoFetch();
+    return () => {
+      if (debounceTimerRef.current !== void 0) {
+        clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = void 0;
+      }
+      queryClient.cache.getAbortController(serializedKey)?.abort();
+      queryClient.cache.clearAbortController(serializedKey);
+    };
+  }, [debouncedDoFetch, options?.enabled]);
+  useEffect(() => {
+    if (options?.enabled === false) return;
+    if (queryClient.cache.isExternallyInvalidated(serializedKey)) debouncedDoFetch();
+  }, [entry, debouncedDoFetch, serializedKey, options?.enabled, queryClient]);
+  useEffect(() => {
+    if (!options?.pollInterval) return;
+    const id = setInterval(() => debouncedDoFetch(true), options.pollInterval);
+    return () => clearInterval(id);
+  }, [debouncedDoFetch, options?.pollInterval]);
+  useEffect(() => {
+    const enabled = options?.refetchOnWindowFocus ?? true;
+    if (!enabled || typeof window === "undefined") return;
+    const handler = () => {
+      if (queryClient.cache.isStale(serializedKey)) debouncedDoFetch();
+    };
+    window.addEventListener("focus", handler);
+    return () => window.removeEventListener("focus", handler);
+  }, [debouncedDoFetch, serializedKey, options?.refetchOnWindowFocus, queryClient]);
+  const rawData = entry?.data;
+  let data = options?.select !== void 0 && rawData !== void 0 ? options.select(rawData) : rawData;
+  let isPlaceholderData = false;
+  if (data === void 0 && entry?.status === "loading" && options?.placeholderData !== void 0) {
+    data = options.placeholderData;
+    isPlaceholderData = true;
+  }
+  if (data !== void 0) {
+    previousDataRef.current = data;
+  } else if (options?.keepPreviousData && previousDataRef.current !== void 0) {
+    data = previousDataRef.current;
+  }
+  return {
+    data,
+    isLoading: entry?.status === "loading" && entry?.data === void 0,
+    isRefetching: entry?.status === "loading" && entry?.data !== void 0,
+    isFetching: entry?.status === "loading",
+    isPlaceholderData,
+    isSuccess: entry?.status === "success",
+    isError: entry?.status === "error",
+    error: entry?.error ?? null,
+    status: entry?.status ?? "idle",
+    refetch: () => void doFetch(true)
+  };
+}
+function useApiMutation(urlOrFn, options) {
+  const { apiClient, queryClient } = useApiContext();
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const [state, setState] = useState({
+    data: void 0,
+    error: null,
+    status: "idle"
+  });
+  const mutateAsync = useCallback(
+    async (variables) => {
+      const { method = "POST", onSuccess, onError, invalidates, optimistic, onUploadProgress } = optionsRef.current ?? {};
+      setState({ data: void 0, error: null, status: "pending" });
+      let previousData;
+      if (optimistic) {
+        await queryClient.cancelQueries({ queryKey: optimistic.queryKey });
+        previousData = queryClient.getQueryData(optimistic.queryKey);
+        queryClient.setQueryData(
+          optimistic.queryKey,
+          (old) => optimistic.updater(old, variables)
+        );
+      }
+      try {
+        const data = typeof urlOrFn === "function" ? await urlOrFn(apiClient.instance, variables) : await apiClient.instance.request({
+          method,
+          url: urlOrFn,
+          data: variables,
+          onUploadProgress: onUploadProgress ? (evt) => {
+            const pct = evt.total ? Math.round(evt.loaded / evt.total * 100) : 0;
+            onUploadProgress(pct);
+          } : void 0
+        }).then((r) => r.data);
+        setState({ data, error: null, status: "success" });
+        if (invalidates?.length) {
+          await Promise.all(
+            invalidates.map((key) => queryClient.invalidateQueries({ queryKey: key }))
+          );
+        }
+        await onSuccess?.(data, variables);
+        return data;
+      } catch (err) {
+        if (optimistic) {
+          queryClient.setQueryData(optimistic.queryKey, previousData);
+        }
+        const apiError = toApiError(err);
+        setState({ data: void 0, error: apiError, status: "error" });
+        onError?.(apiError);
+        throw apiError;
+      }
+    },
+    [apiClient, queryClient, urlOrFn]
+  );
+  const mutate = useCallback(
+    (variables) => {
+      void mutateAsync(variables).catch(() => void 0);
+    },
+    [mutateAsync]
+  );
+  const reset = useCallback(() => {
+    setState({ data: void 0, error: null, status: "idle" });
+  }, []);
+  return {
+    mutate,
+    mutateAsync,
+    data: state.data,
+    isPending: state.status === "pending",
+    isSuccess: state.status === "success",
+    isError: state.status === "error",
+    error: state.error,
+    reset
+  };
+}
+function useInfiniteApiQuery(url, options) {
+  const { apiClient, queryClient } = useApiContext();
+  const cacheKey = serializeKey(["__inf__", url]);
+  const retries = options.retry === false ? 0 : options.retry ?? 1;
+  const staleTime = options.staleTime ?? 6e4;
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const [isFetchingNextPage, setIsFetchingNextPage] = useState(false);
+  const [isFetchingPreviousPage, setIsFetchingPreviousPage] = useState(false);
+  const entry = useSyncExternalStore(
+    (notify) => queryClient.cache.subscribe(cacheKey, notify),
+    () => queryClient.cache.get(cacheKey),
+    () => queryClient.cache.get(cacheKey)
+  );
+  const buildUrl = (pageParam) => {
+    if (pageParam == null) return url;
+    return url + (url.includes("?") ? "&" : "?") + "cursor=" + String(pageParam);
+  };
+  const fetchOnePage = useCallback(
+    (pageParam) => {
+      const currentOptions = optionsRef.current;
+      if (currentOptions.fetchPage) {
+        return withRetry(() => currentOptions.fetchPage(pageParam, apiClient.instance), retries);
+      }
+      return withRetry(
+        () => apiClient.instance.get(buildUrl(pageParam)).then((r) => r.data),
+        retries
+      );
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [apiClient, retries, url]
+  );
+  const doInitialFetch = useCallback(async () => {
+    if (queryClient.cache.getInFlight(cacheKey)) return;
+    queryClient.cache.setLoading(cacheKey);
+    const gen = queryClient.cache.bumpGeneration(cacheKey);
+    const promise = fetchOnePage(void 0);
+    queryClient.cache.setInFlight(cacheKey, promise);
+    try {
+      const firstPage = await promise;
+      if (queryClient.cache.getGeneration(cacheKey) !== gen) return;
+      const infiniteData2 = {
+        pages: [firstPage],
+        pageParams: [void 0]
+      };
+      queryClient.cache.setData(cacheKey, infiniteData2, staleTime);
+    } catch (err) {
+      if (queryClient.cache.getGeneration(cacheKey) !== gen) return;
+      const apiError = toApiError(err);
+      queryClient.cache.setError(cacheKey, apiError);
+    }
+  }, [cacheKey, fetchOnePage, staleTime, queryClient]);
+  useEffect(() => {
+    if (options.enabled === false) return;
+    if (!queryClient.cache.isStale(cacheKey)) return;
+    void doInitialFetch();
+  }, [doInitialFetch, cacheKey, options.enabled, queryClient]);
+  const fetchNextPage = useCallback(() => {
+    const currentData = queryClient.cache.get(cacheKey)?.data;
+    if (!currentData || currentData.pages.length === 0) return;
+    const lastPage = currentData.pages[currentData.pages.length - 1];
+    const nextPageParam = optionsRef.current.getNextPageParam(lastPage, currentData.pages);
+    if (nextPageParam === void 0) return;
+    setIsFetchingNextPage(true);
+    void fetchOnePage(nextPageParam).then((newPage) => {
+      const latestData = queryClient.cache.get(cacheKey)?.data;
+      if (!latestData) return;
+      const updated = {
+        pages: [...latestData.pages, newPage],
+        pageParams: [...latestData.pageParams, nextPageParam]
+      };
+      queryClient.cache.setData(cacheKey, updated, staleTime);
+    }).catch((err) => {
+      const apiError = toApiError(err);
+      queryClient.cache.setError(cacheKey, apiError);
+    }).finally(() => {
+      setIsFetchingNextPage(false);
+    });
+  }, [cacheKey, fetchOnePage, staleTime, queryClient]);
+  const fetchPreviousPage = useCallback(() => {
+    const currentData = queryClient.cache.get(cacheKey)?.data;
+    if (!currentData || currentData.pages.length === 0) return;
+    const getPreviousPageParam = optionsRef.current.getPreviousPageParam;
+    if (!getPreviousPageParam) return;
+    const firstPage = currentData.pages[0];
+    const prevPageParam = getPreviousPageParam(firstPage, currentData.pages);
+    if (prevPageParam === void 0) return;
+    setIsFetchingPreviousPage(true);
+    void fetchOnePage(prevPageParam).then((newPage) => {
+      const latestData = queryClient.cache.get(cacheKey)?.data;
+      if (!latestData) return;
+      const updated = {
+        pages: [newPage, ...latestData.pages],
+        pageParams: [prevPageParam, ...latestData.pageParams]
+      };
+      queryClient.cache.setData(cacheKey, updated, staleTime);
+    }).catch((err) => {
+      const apiError = toApiError(err);
+      queryClient.cache.setError(cacheKey, apiError);
+    }).finally(() => {
+      setIsFetchingPreviousPage(false);
+    });
+  }, [cacheKey, fetchOnePage, staleTime, queryClient]);
+  const refetch = useCallback(() => {
+    queryClient.cache.bumpGeneration(cacheKey);
+    queryClient.cache.clearInFlight(cacheKey);
+    void doInitialFetch();
+  }, [cacheKey, doInitialFetch, queryClient]);
+  const infiniteData = entry?.data;
+  let hasNextPage = false;
+  let hasPreviousPage = false;
+  if (infiniteData && infiniteData.pages.length > 0) {
+    const lastPage = infiniteData.pages[infiniteData.pages.length - 1];
+    hasNextPage = optionsRef.current.getNextPageParam(lastPage, infiniteData.pages) !== void 0;
+    if (optionsRef.current.getPreviousPageParam) {
+      const firstPage = infiniteData.pages[0];
+      hasPreviousPage = optionsRef.current.getPreviousPageParam(firstPage, infiniteData.pages) !== void 0;
+    }
+  }
+  return {
+    data: infiniteData,
+    isLoading: entry?.status === "loading" && entry?.data === void 0,
+    isFetching: entry?.status === "loading",
+    isFetchingNextPage,
+    isFetchingPreviousPage,
+    isSuccess: entry?.status === "success",
+    isError: entry?.status === "error",
+    error: entry?.error ?? null,
+    hasNextPage,
+    hasPreviousPage,
+    fetchNextPage,
+    fetchPreviousPage,
+    refetch
+  };
+}
+function useApiQueries(queries) {
+  const { apiClient, queryClient } = useApiContext();
+  const keys = queries.map((q) => serializeKey(q.key ?? [q.url]));
+  const keysJoined = keys.join(",");
+  const prevSnapshotRef = useRef([]);
+  const previousDataRef = useRef([]);
+  const getSnapshot = useCallback(() => {
+    const next = keys.map((k) => queryClient.cache.get(k));
+    if (next.length === prevSnapshotRef.current.length && next.every((e, i) => e === prevSnapshotRef.current[i])) {
+      return prevSnapshotRef.current;
+    }
+    prevSnapshotRef.current = next;
+    return next;
+  }, [keysJoined, queryClient]);
+  const subscribe = useCallback(
+    (notify) => {
+      const unsubs = keys.map((k) => queryClient.cache.subscribe(k, notify));
+      return () => unsubs.forEach((u) => u());
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [keysJoined, queryClient]
+  );
+  const entries = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const doFetchOne = useCallback(
+    (query, key, force = false) => {
+      const opts = query.options;
+      if (!force && !queryClient.cache.isStale(key)) return;
+      if (queryClient.cache.getInFlight(key)) return;
+      const retries = opts?.retry === false ? 0 : opts?.retry ?? 1;
+      const st = opts?.staleTime ?? 6e4;
+      queryClient.cache.setLoading(key);
+      const gen = queryClient.cache.bumpGeneration(key);
+      const promise = withRetry(
+        () => apiClient.instance.get(query.url).then((r) => r.data),
+        retries
+      );
+      queryClient.cache.setInFlight(key, promise);
+      void promise.then((data) => {
+        if (queryClient.cache.getGeneration(key) !== gen) return;
+        queryClient.cache.setData(key, data, st);
+      }).catch((err) => {
+        if (queryClient.cache.getGeneration(key) !== gen) return;
+        const apiError = toApiError(err);
+        queryClient.cache.setError(key, apiError);
+      });
+    },
+    [apiClient, queryClient]
+  );
+  useEffect(() => {
+    queries.forEach((query, i) => {
+      if (query.options?.enabled === false) return;
+      doFetchOne(query, keys[i]);
+    });
+  }, [keysJoined, queryClient, apiClient, doFetchOne]);
+  return entries.map((entry, i) => {
+    const query = queries[i];
+    const opts = query?.options;
+    const key = keys[i];
+    const rawData = entry?.data;
+    let data = opts?.select !== void 0 && rawData !== void 0 ? opts.select(rawData) : rawData;
+    let isPlaceholderData = false;
+    if (data === void 0 && entry?.status === "loading" && opts?.placeholderData !== void 0) {
+      data = opts.placeholderData;
+      isPlaceholderData = true;
+    }
+    if (data !== void 0) {
+      previousDataRef.current[i] = data;
+    } else if (opts?.keepPreviousData && previousDataRef.current[i] !== void 0) {
+      data = previousDataRef.current[i];
+    }
+    return {
+      data,
+      isLoading: entry?.status === "loading" && entry?.data === void 0,
+      isRefetching: entry?.status === "loading" && entry?.data !== void 0,
+      isFetching: entry?.status === "loading",
+      isPlaceholderData,
+      isSuccess: entry?.status === "success",
+      isError: entry?.status === "error",
+      error: entry?.error ?? null,
+      status: entry?.status ?? "idle",
+      refetch: () => {
+        if (!key || !query) return;
+        doFetchOne(query, key, true);
+      }
+    };
+  });
+}
+function useSuspenseApiQuery(url, options) {
+  const { apiClient, queryClient } = useApiContext();
+  const serializedKey = serializeKey([url]);
+  const retries = options?.retry === false ? 0 : options?.retry ?? 1;
+  const staleTime = options?.staleTime ?? 6e4;
+  const entry = useSyncExternalStore(
+    (notify) => queryClient.cache.subscribe(serializedKey, notify),
+    () => queryClient.cache.get(serializedKey),
+    () => queryClient.cache.get(serializedKey)
+  );
+  if (!entry || entry.status === "loading" || entry.status === "idle" && !entry.data) {
+    const existing = queryClient.cache.getInFlight(serializedKey);
+    if (existing) {
+      throw existing;
+    }
+    const gen = queryClient.cache.bumpGeneration(serializedKey);
+    queryClient.cache.setLoading(serializedKey);
+    const p = withRetry(
+      () => apiClient.instance.get(url).then((r) => r.data),
+      retries
+    ).then((data) => {
+      if (queryClient.cache.getGeneration(serializedKey) === gen) {
+        queryClient.cache.setData(serializedKey, data, staleTime);
+      }
+    }).catch((err) => {
+      if (queryClient.cache.getGeneration(serializedKey) === gen) {
+        const apiError = toApiError(err);
+        queryClient.cache.setError(serializedKey, apiError);
+        throw apiError;
+      }
+    });
+    queryClient.cache.setInFlight(serializedKey, p);
+    throw p;
+  }
+  if (entry.status === "error") {
+    throw entry.error;
+  }
+  const refetch = () => {
+    queryClient.cache.clearInFlight(serializedKey);
+    const gen = queryClient.cache.bumpGeneration(serializedKey);
+    const p = withRetry(
+      () => apiClient.instance.get(url).then((r) => r.data),
+      retries
+    ).then((data) => {
+      if (queryClient.cache.getGeneration(serializedKey) === gen) {
+        queryClient.cache.setData(serializedKey, data, staleTime);
+      }
+    }).catch((err) => {
+      if (queryClient.cache.getGeneration(serializedKey) === gen) {
+        queryClient.cache.setError(serializedKey, toApiError(err));
+      }
+    });
+    queryClient.cache.setInFlight(serializedKey, p);
+  };
+  return {
+    data: entry.data,
+    isFetching: false,
+    isRefetching: false,
+    isSuccess: true,
+    refetch
+  };
+}
+function usePrefetch(url, options) {
+  const { apiClient, queryClient } = useApiContext();
+  const prefetch = useCallback(() => {
+    void queryClient.prefetchQuery({
+      queryKey: [url],
+      queryFn: () => apiClient.instance.get(url).then((r) => r.data),
+      staleTime: options?.staleTime
+    });
+  }, [url, queryClient, apiClient, options?.staleTime]);
+  return prefetch;
+}
+
+// src/persistence.ts
+async function persistCache(queryClient, config) {
+  const storageKey = config.key ?? "structyl-cache";
+  const maxAge = config.maxAge ?? 24 * 60 * 6e4;
+  try {
+    const raw = await config.storage.getItem(storageKey);
+    if (raw) {
+      const parsed = JSON.parse(raw);
+      if (parsed.savedAt + maxAge > Date.now()) {
+        queryClient.cache.restore(parsed.entries);
+      } else {
+        void config.storage.removeItem(storageKey);
+      }
+    }
+  } catch {
+  }
+  let debounceTimer;
+  const write = () => {
+    if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      debounceTimer = void 0;
+      const snapshot = queryClient.cache.snapshot();
+      const payload = {
+        entries: snapshot,
+        savedAt: Date.now()
+      };
+      void config.storage.setItem(storageKey, JSON.stringify(payload));
+    }, 1e3);
+  };
+  const unsubscribe = queryClient.cache.subscribeGlobal(write);
+  return () => {
+    unsubscribe();
+    if (debounceTimer !== void 0) {
+      clearTimeout(debounceTimer);
+      debounceTimer = void 0;
+    }
+  };
+}
+
+export { ApiClient, ApiProvider, QueryClient, createApiClient, persistCache, useApiClient, useApiContext, useApiMutation, useApiQueries, useApiQuery, useInfiniteApiQuery, usePrefetch, useSuspenseApiQuery };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map