@usebridge/sdk-react 0.7.2 → 0.8.0

package/dist/index.cjs

@@ -549,6 +549,9 @@ function useIsMounted() {
   return (0, import_react4.useCallback)(() => isMounted.current, []);
 }
 
+// src/payer-search/use-payer-autocomplete.ts
+var import_api = require("@usebridge/api");
+
 // src/lib/retry-loop.ts
 var RetryLoopCancelledError = class extends Error {
   constructor() {
@@ -556,20 +559,22 @@ var RetryLoopCancelledError = class extends Error {
     this.name = "RetryLoopCancelledError";
   }
 };
-async function retryLoop(fn, shouldRetry, delayMs = 500) {
-  let cancelled = false;
-  while (!cancelled) {
+async function retryLoop(fn, getRetryDecision, delayMs = 500) {
+  let decision = "retry";
+  let lastError;
+  while (decision === "retry") {
     try {
       return await fn();
-    } catch (_) {
-      if (!shouldRetry()) {
-        cancelled = true;
-      } else {
+    } catch (err) {
+      lastError = err;
+      decision = getRetryDecision(err);
+      if (decision === "retry") {
         await new Promise((r) => setTimeout(r, delayMs));
       }
     }
   }
-  throw new RetryLoopCancelledError();
+  if (decision === "cancel") throw new RetryLoopCancelledError();
+  throw lastError;
 }
 
 // src/payer-search/use-payer-search.ts
@@ -2128,45 +2133,71 @@ var omit_default = omit;
 
 // src/payer-search/use-payer-autocomplete.ts
 var resultCache = /* @__PURE__ */ new Map();
+function toCacheKey(normalizedQuery, limit) {
+  return `${limit}:${normalizedQuery}`;
+}
+function toError(err) {
+  if (err instanceof Error) return err;
+  return new Error(String(err));
+}
+function isRetryablePayerSearchError(err) {
+  if (err instanceof import_api.BridgeApiError && err.statusCode != null) {
+    if (err.statusCode === 429 || err.statusCode === 408) return true;
+    if (err.statusCode >= 400 && err.statusCode < 500) return false;
+  }
+  return true;
+}
 function usePayerAutocomplete(query, {
   limit = 10
 } = {}) {
   const payerSearch = usePayerSearch();
   const [isLoading, setIsLoading] = (0, import_react6.useState)(false);
   const [results, setResults] = (0, import_react6.useState)([]);
+  const [error, setError] = (0, import_react6.useState)();
   const normalizedQuery = query.trim().toLowerCase();
   const reqId = (0, import_react6.useRef)(0);
   const isMounted = useIsMounted();
   (0, import_react6.useEffect)(() => {
     const thisId = ++reqId.current;
-    const cachedResults = resultCache.get(normalizedQuery);
+    const cacheKey = toCacheKey(normalizedQuery, limit);
+    const cachedResults = resultCache.get(cacheKey);
     if (cachedResults) {
       setIsLoading(false);
       setResults(cachedResults);
+      setError(void 0);
       return;
     }
     async function run() {
       setIsLoading(true);
+      setError(void 0);
       try {
         const response = await retryLoop(
           () => payerSearch({ query: normalizedQuery, limit }),
-          () => isMounted() && thisId === reqId.current
+          (err) => {
+            if (!isMounted() || thisId !== reqId.current) return "cancel";
+            if (!isRetryablePayerSearchError(err)) return "fail";
+            return "retry";
+          }
         );
         if (!isMounted()) return;
-        resultCache.set(normalizedQuery, response.items);
+        resultCache.set(cacheKey, response.items);
         if (thisId !== reqId.current) return;
         setIsLoading(false);
         setResults(response.items);
+        setError(void 0);
       } catch (err) {
         if (err instanceof RetryLoopCancelledError) return;
-        throw err;
+        if (!isMounted() || thisId !== reqId.current) return;
+        setResults([]);
+        setIsLoading(false);
+        setError(toError(err));
       }
     }
     void run();
   }, [payerSearch, normalizedQuery, limit]);
   return (0, import_react6.useMemo)(
-    () => ({ isLoading, results: results.map((r) => omit_default(r, "code")) }),
-    [isLoading, results]
+    () => ({ isLoading, results: results.map((r) => omit_default(r, "code")), error }),
+    [isLoading, results, error]
   );
 }