@yashrsb/retry-kit 0.1.0

package/README.md

@@ -0,0 +1,196 @@
+# retry-kit
+
+A small TypeScript utility for retrying failed asynchronous operations with exponential backoff.
+
+## Installation
+
+```bash
+npm install retry-kit
+```
+
+## Usage
+
+```ts
+import { retry } from "retry-kit";
+
+const result = await retry(
+  async () => {
+    return await fetchData();
+  },
+  {
+    retries: 3,
+    delay: 500,
+    maxDelay: 5000,
+    jitter: true,
+  },
+);
+
+console.log(result);
+```
+
+If the operation fails, `retry-kit` waits before trying again.
+
+With the configuration above, the base exponential delays are:
+
+```text
+500ms → 1000ms → 2000ms → 4000ms
+```
+
+The `maxDelay` option limits the maximum wait time.
+
+When `jitter` is enabled, the actual delay is randomized between `0` and the calculated backoff delay.
+
+## API
+
+### `retry<T>(fn, options?)`
+
+Retries an asynchronous operation until it succeeds or the configured number of retries is exhausted.
+
+### Options
+
+| Option     |     Default | Description                                               |
+| ---------- | ----------: | --------------------------------------------------------- |
+| `retries`  |         `3` | Number of retries after the initial attempt               |
+| `delay`    |       `500` | Initial delay in milliseconds                             |
+| `maxDelay` |  `Infinity` | Maximum delay between attempts                            |
+| `jitter`   |     `false` | Randomizes the backoff delay                              |
+| `signal`   | `undefined` | Optional `AbortSignal` used to cancel the retry operation |
+
+### Example: Retry a failing operation
+
+```ts
+const result = await retry(
+  async () => {
+    return await fetchData();
+  },
+  {
+    retries: 3,
+    delay: 500,
+  },
+);
+```
+
+The operation is attempted once initially. If it fails, it can be retried up to three additional times.
+
+Therefore:
+
+```text
+retries: 3
+```
+
+means a maximum of:
+
+```text
+4 total attempts
+```
+
+### Example: Exponential backoff
+
+With:
+
+```ts
+{
+  retries: 4,
+  delay: 500,
+}
+```
+
+the delays between attempts are:
+
+```text
+500ms
+1000ms
+2000ms
+4000ms
+```
+
+### Example: Maximum delay
+
+```ts
+{
+  retries: 10,
+  delay: 500,
+  maxDelay: 2000,
+}
+```
+
+The delay will never exceed `2000ms`:
+
+```text
+500ms
+1000ms
+2000ms
+2000ms
+2000ms
+...
+```
+
+### Example: Jitter
+
+```ts
+{
+  retries: 5,
+  delay: 500,
+  jitter: true,
+}
+```
+
+Jitter randomizes the calculated backoff delay. This can help avoid many clients retrying at exactly the same time.
+
+### Example: Cancellation
+
+```ts
+const controller = new AbortController();
+
+const result = retry(
+  async () => {
+    return await fetchData();
+  },
+  {
+    retries: 5,
+    delay: 500,
+    signal: controller.signal,
+  },
+);
+
+controller.abort();
+```
+
+Aborting the signal stops the retry operation.
+
+## Behavior
+
+The package:
+
+- Executes the operation immediately.
+- Retries rejected operations according to the configured retry count.
+- Uses exponential backoff between retries.
+- Supports a maximum backoff delay.
+- Supports full jitter.
+- Preserves and throws the final operation error when retries are exhausted.
+- Supports cancellation through `AbortSignal`.
+- Provides TypeScript declarations.
+
+## Development
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+Run tests:
+
+```bash
+npm test
+```
+
+Build the package:
+
+```bash
+npm run build
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  retry: () => retry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/retry.ts
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      cleanup();
+      reject(signal?.reason);
+    }
+    function cleanup() {
+      signal?.removeEventListener("abort", onAbort);
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function applyJitter(delay) {
+  return Math.random() * delay;
+}
+function validateOptions(fn, retries, delay, maxDelay, jitter, signal) {
+  if (typeof fn !== "function") {
+    throw new TypeError("retry: fn must be a function");
+  }
+  if (!Number.isInteger(retries) || retries < 0) {
+    throw new RangeError("retry: retries must be a non-negative integer");
+  }
+  if (!Number.isFinite(delay) || delay < 0) {
+    throw new RangeError("retry: delay must be a non-negative finite number");
+  }
+  if (maxDelay !== Infinity && (!Number.isFinite(maxDelay) || maxDelay < 0)) {
+    throw new RangeError(
+      "retry: maxDelay must be a non-negative finite number"
+    );
+  }
+  if (maxDelay < delay) {
+    throw new RangeError(
+      "retry: maxDelay must be greater than or equal to delay"
+    );
+  }
+  if (typeof jitter !== "boolean") {
+    throw new TypeError("retry: jitter must be a boolean");
+  }
+  if (signal !== void 0 && !(signal instanceof AbortSignal)) {
+    throw new TypeError("retry: signal must be an AbortSignal");
+  }
+}
+async function retry(fn, options = {}) {
+  const {
+    retries = 3,
+    delay = 500,
+    maxDelay = Infinity,
+    jitter = false,
+    signal
+  } = options;
+  validateOptions(fn, retries, delay, maxDelay, jitter, signal);
+  let attempt = 0;
+  while (true) {
+    if (signal?.aborted) {
+      throw signal.reason;
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt >= retries) {
+        throw error;
+      }
+      const backoffDelay = Math.min(delay * 2 ** attempt, maxDelay);
+      const actualDelay = jitter ? applyJitter(backoffDelay) : backoffDelay;
+      await sleep(actualDelay, signal);
+      attempt++;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  retry
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/retry.ts"],"sourcesContent":["export { retry } from \"./retry.js\";\r\nexport type { RetryOptions } from \"./retry.js\";\r\n","export interface RetryOptions {\r\n  retries?: number;\r\n  delay?: number;\r\n  maxDelay?: number;\r\n  jitter?: boolean;\r\n  signal?: AbortSignal;\r\n}\r\n\r\nfunction sleep(ms: number, signal?: AbortSignal): Promise<void> {\r\n  return new Promise((resolve, reject) => {\r\n    if (signal?.aborted) {\r\n      reject(signal.reason);\r\n      return;\r\n    }\r\n\r\n    const timer = setTimeout(() => {\r\n      cleanup();\r\n      resolve();\r\n    }, ms);\r\n\r\n    function onAbort(): void {\r\n      clearTimeout(timer);\r\n      cleanup();\r\n      reject(signal?.reason);\r\n    }\r\n\r\n    function cleanup(): void {\r\n      signal?.removeEventListener(\"abort\", onAbort);\r\n    }\r\n\r\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\r\n  });\r\n}\r\n\r\nfunction applyJitter(delay: number): number {\r\n  return Math.random() * delay;\r\n}\r\n\r\nfunction validateOptions(\r\n  fn: unknown,\r\n  retries: number,\r\n  delay: number,\r\n  maxDelay: number,\r\n  jitter: boolean,\r\n  signal?: AbortSignal,\r\n): void {\r\n  if (typeof fn !== \"function\") {\r\n    throw new TypeError(\"retry: fn must be a function\");\r\n  }\r\n\r\n  if (!Number.isInteger(retries) || retries < 0) {\r\n    throw new RangeError(\"retry: retries must be a non-negative integer\");\r\n  }\r\n\r\n  if (!Number.isFinite(delay) || delay < 0) {\r\n    throw new RangeError(\"retry: delay must be a non-negative finite number\");\r\n  }\r\n\r\n  if (maxDelay !== Infinity && (!Number.isFinite(maxDelay) || maxDelay < 0)) {\r\n    throw new RangeError(\r\n      \"retry: maxDelay must be a non-negative finite number\",\r\n    );\r\n  }\r\n\r\n  if (maxDelay < delay) {\r\n    throw new RangeError(\r\n      \"retry: maxDelay must be greater than or equal to delay\",\r\n    );\r\n  }\r\n\r\n  if (typeof jitter !== \"boolean\") {\r\n    throw new TypeError(\"retry: jitter must be a boolean\");\r\n  }\r\n\r\n  if (signal !== undefined && !(signal instanceof AbortSignal)) {\r\n    throw new TypeError(\"retry: signal must be an AbortSignal\");\r\n  }\r\n}\r\n\r\nexport async function retry<T>(\r\n  fn: () => Promise<T>,\r\n  options: RetryOptions = {},\r\n): Promise<T> {\r\n  const {\r\n    retries = 3,\r\n    delay = 500,\r\n    maxDelay = Infinity,\r\n    jitter = false,\r\n    signal,\r\n  } = options;\r\n\r\n  validateOptions(fn, retries, delay, maxDelay, jitter, signal);\r\n\r\n  let attempt = 0;\r\n\r\n  while (true) {\r\n    if (signal?.aborted) {\r\n      throw signal.reason;\r\n    }\r\n\r\n    try {\r\n      return await fn();\r\n    } catch (error) {\r\n      if (attempt >= retries) {\r\n        throw error;\r\n      }\r\n\r\n      const backoffDelay = Math.min(delay * 2 ** attempt, maxDelay);\r\n\r\n      const actualDelay = jitter ? applyJitter(backoffDelay) : backoffDelay;\r\n\r\n      await sleep(actualDelay, signal);\r\n\r\n      attempt++;\r\n    }\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACQA,SAAS,MAAM,IAAY,QAAqC;AAC9D,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,QAAI,QAAQ,SAAS;AACnB,aAAO,OAAO,MAAM;AACpB;AAAA,IACF;AAEA,UAAM,QAAQ,WAAW,MAAM;AAC7B,cAAQ;AACR,cAAQ;AAAA,IACV,GAAG,EAAE;AAEL,aAAS,UAAgB;AACvB,mBAAa,KAAK;AAClB,cAAQ;AACR,aAAO,QAAQ,MAAM;AAAA,IACvB;AAEA,aAAS,UAAgB;AACvB,cAAQ,oBAAoB,SAAS,OAAO;AAAA,IAC9C;AAEA,YAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,EAC3D,CAAC;AACH;AAEA,SAAS,YAAY,OAAuB;AAC1C,SAAO,KAAK,OAAO,IAAI;AACzB;AAEA,SAAS,gBACP,IACA,SACA,OACA,UACA,QACA,QACM;AACN,MAAI,OAAO,OAAO,YAAY;AAC5B,UAAM,IAAI,UAAU,8BAA8B;AAAA,EACpD;AAEA,MAAI,CAAC,OAAO,UAAU,OAAO,KAAK,UAAU,GAAG;AAC7C,UAAM,IAAI,WAAW,+CAA+C;AAAA,EACtE;AAEA,MAAI,CAAC,OAAO,SAAS,KAAK,KAAK,QAAQ,GAAG;AACxC,UAAM,IAAI,WAAW,mDAAmD;AAAA,EAC1E;AAEA,MAAI,aAAa,aAAa,CAAC,OAAO,SAAS,QAAQ,KAAK,WAAW,IAAI;AACzE,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,MAAI,WAAW,OAAO;AACpB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,MAAI,OAAO,WAAW,WAAW;AAC/B,UAAM,IAAI,UAAU,iCAAiC;AAAA,EACvD;AAEA,MAAI,WAAW,UAAa,EAAE,kBAAkB,cAAc;AAC5D,UAAM,IAAI,UAAU,sCAAsC;AAAA,EAC5D;AACF;AAEA,eAAsB,MACpB,IACA,UAAwB,CAAC,GACb;AACZ,QAAM;AAAA,IACJ,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,WAAW;AAAA,IACX,SAAS;AAAA,IACT;AAAA,EACF,IAAI;AAEJ,kBAAgB,IAAI,SAAS,OAAO,UAAU,QAAQ,MAAM;AAE5D,MAAI,UAAU;AAEd,SAAO,MAAM;AACX,QAAI,QAAQ,SAAS;AACnB,YAAM,OAAO;AAAA,IACf;AAEA,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,SAAS,OAAO;AACd,UAAI,WAAW,SAAS;AACtB,cAAM;AAAA,MACR;AAEA,YAAM,eAAe,KAAK,IAAI,QAAQ,KAAK,SAAS,QAAQ;AAE5D,YAAM,cAAc,SAAS,YAAY,YAAY,IAAI;AAEzD,YAAM,MAAM,aAAa,MAAM;AAE/B;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,10 @@
+interface RetryOptions {
+    retries?: number;
+    delay?: number;
+    maxDelay?: number;
+    jitter?: boolean;
+    signal?: AbortSignal;
+}
+declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+export { type RetryOptions, retry };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+interface RetryOptions {
+    retries?: number;
+    delay?: number;
+    maxDelay?: number;
+    jitter?: boolean;
+    signal?: AbortSignal;
+}
+declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+export { type RetryOptions, retry };

package/dist/index.js

@@ -0,0 +1,83 @@
+// src/retry.ts
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      cleanup();
+      reject(signal?.reason);
+    }
+    function cleanup() {
+      signal?.removeEventListener("abort", onAbort);
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function applyJitter(delay) {
+  return Math.random() * delay;
+}
+function validateOptions(fn, retries, delay, maxDelay, jitter, signal) {
+  if (typeof fn !== "function") {
+    throw new TypeError("retry: fn must be a function");
+  }
+  if (!Number.isInteger(retries) || retries < 0) {
+    throw new RangeError("retry: retries must be a non-negative integer");
+  }
+  if (!Number.isFinite(delay) || delay < 0) {
+    throw new RangeError("retry: delay must be a non-negative finite number");
+  }
+  if (maxDelay !== Infinity && (!Number.isFinite(maxDelay) || maxDelay < 0)) {
+    throw new RangeError(
+      "retry: maxDelay must be a non-negative finite number"
+    );
+  }
+  if (maxDelay < delay) {
+    throw new RangeError(
+      "retry: maxDelay must be greater than or equal to delay"
+    );
+  }
+  if (typeof jitter !== "boolean") {
+    throw new TypeError("retry: jitter must be a boolean");
+  }
+  if (signal !== void 0 && !(signal instanceof AbortSignal)) {
+    throw new TypeError("retry: signal must be an AbortSignal");
+  }
+}
+async function retry(fn, options = {}) {
+  const {
+    retries = 3,
+    delay = 500,
+    maxDelay = Infinity,
+    jitter = false,
+    signal
+  } = options;
+  validateOptions(fn, retries, delay, maxDelay, jitter, signal);
+  let attempt = 0;
+  while (true) {
+    if (signal?.aborted) {
+      throw signal.reason;
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt >= retries) {
+        throw error;
+      }
+      const backoffDelay = Math.min(delay * 2 ** attempt, maxDelay);
+      const actualDelay = jitter ? applyJitter(backoffDelay) : backoffDelay;
+      await sleep(actualDelay, signal);
+      attempt++;
+    }
+  }
+}
+export {
+  retry
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/retry.ts"],"sourcesContent":["export interface RetryOptions {\r\n  retries?: number;\r\n  delay?: number;\r\n  maxDelay?: number;\r\n  jitter?: boolean;\r\n  signal?: AbortSignal;\r\n}\r\n\r\nfunction sleep(ms: number, signal?: AbortSignal): Promise<void> {\r\n  return new Promise((resolve, reject) => {\r\n    if (signal?.aborted) {\r\n      reject(signal.reason);\r\n      return;\r\n    }\r\n\r\n    const timer = setTimeout(() => {\r\n      cleanup();\r\n      resolve();\r\n    }, ms);\r\n\r\n    function onAbort(): void {\r\n      clearTimeout(timer);\r\n      cleanup();\r\n      reject(signal?.reason);\r\n    }\r\n\r\n    function cleanup(): void {\r\n      signal?.removeEventListener(\"abort\", onAbort);\r\n    }\r\n\r\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\r\n  });\r\n}\r\n\r\nfunction applyJitter(delay: number): number {\r\n  return Math.random() * delay;\r\n}\r\n\r\nfunction validateOptions(\r\n  fn: unknown,\r\n  retries: number,\r\n  delay: number,\r\n  maxDelay: number,\r\n  jitter: boolean,\r\n  signal?: AbortSignal,\r\n): void {\r\n  if (typeof fn !== \"function\") {\r\n    throw new TypeError(\"retry: fn must be a function\");\r\n  }\r\n\r\n  if (!Number.isInteger(retries) || retries < 0) {\r\n    throw new RangeError(\"retry: retries must be a non-negative integer\");\r\n  }\r\n\r\n  if (!Number.isFinite(delay) || delay < 0) {\r\n    throw new RangeError(\"retry: delay must be a non-negative finite number\");\r\n  }\r\n\r\n  if (maxDelay !== Infinity && (!Number.isFinite(maxDelay) || maxDelay < 0)) {\r\n    throw new RangeError(\r\n      \"retry: maxDelay must be a non-negative finite number\",\r\n    );\r\n  }\r\n\r\n  if (maxDelay < delay) {\r\n    throw new RangeError(\r\n      \"retry: maxDelay must be greater than or equal to delay\",\r\n    );\r\n  }\r\n\r\n  if (typeof jitter !== \"boolean\") {\r\n    throw new TypeError(\"retry: jitter must be a boolean\");\r\n  }\r\n\r\n  if (signal !== undefined && !(signal instanceof AbortSignal)) {\r\n    throw new TypeError(\"retry: signal must be an AbortSignal\");\r\n  }\r\n}\r\n\r\nexport async function retry<T>(\r\n  fn: () => Promise<T>,\r\n  options: RetryOptions = {},\r\n): Promise<T> {\r\n  const {\r\n    retries = 3,\r\n    delay = 500,\r\n    maxDelay = Infinity,\r\n    jitter = false,\r\n    signal,\r\n  } = options;\r\n\r\n  validateOptions(fn, retries, delay, maxDelay, jitter, signal);\r\n\r\n  let attempt = 0;\r\n\r\n  while (true) {\r\n    if (signal?.aborted) {\r\n      throw signal.reason;\r\n    }\r\n\r\n    try {\r\n      return await fn();\r\n    } catch (error) {\r\n      if (attempt >= retries) {\r\n        throw error;\r\n      }\r\n\r\n      const backoffDelay = Math.min(delay * 2 ** attempt, maxDelay);\r\n\r\n      const actualDelay = jitter ? applyJitter(backoffDelay) : backoffDelay;\r\n\r\n      await sleep(actualDelay, signal);\r\n\r\n      attempt++;\r\n    }\r\n  }\r\n}\r\n"],"mappings":";AAQA,SAAS,MAAM,IAAY,QAAqC;AAC9D,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,QAAI,QAAQ,SAAS;AACnB,aAAO,OAAO,MAAM;AACpB;AAAA,IACF;AAEA,UAAM,QAAQ,WAAW,MAAM;AAC7B,cAAQ;AACR,cAAQ;AAAA,IACV,GAAG,EAAE;AAEL,aAAS,UAAgB;AACvB,mBAAa,KAAK;AAClB,cAAQ;AACR,aAAO,QAAQ,MAAM;AAAA,IACvB;AAEA,aAAS,UAAgB;AACvB,cAAQ,oBAAoB,SAAS,OAAO;AAAA,IAC9C;AAEA,YAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,EAC3D,CAAC;AACH;AAEA,SAAS,YAAY,OAAuB;AAC1C,SAAO,KAAK,OAAO,IAAI;AACzB;AAEA,SAAS,gBACP,IACA,SACA,OACA,UACA,QACA,QACM;AACN,MAAI,OAAO,OAAO,YAAY;AAC5B,UAAM,IAAI,UAAU,8BAA8B;AAAA,EACpD;AAEA,MAAI,CAAC,OAAO,UAAU,OAAO,KAAK,UAAU,GAAG;AAC7C,UAAM,IAAI,WAAW,+CAA+C;AAAA,EACtE;AAEA,MAAI,CAAC,OAAO,SAAS,KAAK,KAAK,QAAQ,GAAG;AACxC,UAAM,IAAI,WAAW,mDAAmD;AAAA,EAC1E;AAEA,MAAI,aAAa,aAAa,CAAC,OAAO,SAAS,QAAQ,KAAK,WAAW,IAAI;AACzE,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,MAAI,WAAW,OAAO;AACpB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,MAAI,OAAO,WAAW,WAAW;AAC/B,UAAM,IAAI,UAAU,iCAAiC;AAAA,EACvD;AAEA,MAAI,WAAW,UAAa,EAAE,kBAAkB,cAAc;AAC5D,UAAM,IAAI,UAAU,sCAAsC;AAAA,EAC5D;AACF;AAEA,eAAsB,MACpB,IACA,UAAwB,CAAC,GACb;AACZ,QAAM;AAAA,IACJ,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,WAAW;AAAA,IACX,SAAS;AAAA,IACT;AAAA,EACF,IAAI;AAEJ,kBAAgB,IAAI,SAAS,OAAO,UAAU,QAAQ,MAAM;AAE5D,MAAI,UAAU;AAEd,SAAO,MAAM;AACX,QAAI,QAAQ,SAAS;AACnB,YAAM,OAAO;AAAA,IACf;AAEA,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,SAAS,OAAO;AACd,UAAI,WAAW,SAAS;AACtB,cAAM;AAAA,MACR;AAEA,YAAM,eAAe,KAAK,IAAI,QAAQ,KAAK,SAAS,QAAQ;AAE5D,YAAM,cAAc,SAAS,YAAY,YAAY,IAAI;AAEzD,YAAM,MAAM,aAAa,MAAM;AAE/B;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@yashrsb/retry-kit",
+  "version": "0.1.0",
+  "description": "Retry asynchronous operations with exponential backoff",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check",
+    "build": "tsup"
+  },
+  "keywords": [
+    "retry",
+    "exponential-backoff",
+    "backoff",
+    "async"
+  ],
+  "author": "",
+  "license": "MIT",
+  "type": "module",
+  "devDependencies": {
+    "prettier": "^3.9.6",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.3",
+    "vitest": "^5.0.0"
+  }
+}