@valentinkolb/sync 2.2.0 → 3.0.0

package/browser/retry.js

@@ -0,0 +1,94 @@
+// src/browser/internal/sleep.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var createAbortError = () => {
+  const error = new Error("sleep aborted");
+  error.name = "AbortError";
+  return error;
+};
+var sleepWithSignal = async (delayMs, signal) => {
+  if (delayMs <= 0)
+    return;
+  if (!signal) {
+    await sleep(delayMs);
+    return;
+  }
+  if (signal.aborted)
+    throw createAbortError();
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(createAbortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+};
+
+// src/browser/retry.ts
+var asError = (error) => error instanceof Error ? error : new Error(String(error));
+var createAbortError2 = () => {
+  const error = new Error("retry aborted");
+  error.name = "AbortError";
+  return error;
+};
+var parseCode = (error) => {
+  if (!error || typeof error !== "object")
+    return "";
+  const code = error.code;
+  return typeof code === "string" ? code.toUpperCase() : "";
+};
+var isRetryableTransportError = (error) => {
+  const code = parseCode(error);
+  if (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "EPIPE" || code === "EHOSTUNREACH" || code === "ECONNABORTED") {
+    return true;
+  }
+  const message = asError(error).message.toLowerCase();
+  return message.includes("econnreset") || message.includes("etimedout") || message.includes("connection") || message.includes("socket") || message.includes("broken pipe") || message.includes("network") || message.includes("loading") || message.includes("tryagain") || message.includes("clusterdown");
+};
+var DEFAULT_RETRY_OPTIONS = {
+  attempts: 8,
+  minDelayMs: 100,
+  maxDelayMs: 2000,
+  factor: 2,
+  jitter: 0.2,
+  retryIf: isRetryableTransportError
+};
+var computeDelayMs = (attempt, opts) => {
+  const base = opts.minDelayMs * opts.factor ** Math.max(0, attempt - 1);
+  const capped = Math.min(opts.maxDelayMs, base);
+  const spread = capped * opts.jitter;
+  const jittered = capped + (Math.random() * 2 - 1) * spread;
+  return Math.max(0, Math.floor(jittered));
+};
+var retry = async (fn, opts = {}) => {
+  const attempts = Math.max(1, opts.attempts ?? DEFAULT_RETRY_OPTIONS.attempts);
+  const minDelayMs = Math.max(0, opts.minDelayMs ?? DEFAULT_RETRY_OPTIONS.minDelayMs);
+  const maxDelayMs = Math.max(minDelayMs, opts.maxDelayMs ?? DEFAULT_RETRY_OPTIONS.maxDelayMs);
+  const factor = Math.max(1, opts.factor ?? DEFAULT_RETRY_OPTIONS.factor);
+  const jitter = Math.min(1, Math.max(0, opts.jitter ?? DEFAULT_RETRY_OPTIONS.jitter));
+  const retryIf = opts.retryIf ?? DEFAULT_RETRY_OPTIONS.retryIf;
+  for (let attempt = 1;attempt <= attempts; attempt++) {
+    if (opts.signal?.aborted)
+      throw createAbortError2();
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      if (attempt >= attempts)
+        throw error;
+      if (!retryIf(error))
+        throw error;
+      const delayMs = computeDelayMs(attempt, { minDelayMs, maxDelayMs, factor, jitter });
+      await sleepWithSignal(delayMs, opts.signal);
+    }
+  }
+  throw new Error("unreachable retry state");
+};
+export {
+  retry,
+  isRetryableTransportError,
+  DEFAULT_RETRY_OPTIONS
+};