@zap-studio/retry 0.3.0 → 0.3.1

package/dist/throw-mode.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"throw-mode.mjs","names":[],"sources":["../src/throw-mode.ts"],"sourcesContent":["/**\n * Throw-mode execution path for `BaseRetryPolicy.run` (default when\n * `throwOnExhausted` is not `false`).\n *\n * @module @zap-studio/retry/throw-mode\n */\n\nimport { sleepWithAbortSignal, throwIfAborted } from \"./abort.js\";\nimport { RetryError } from \"./errors.js\";\nimport type { RetryDecision, RetryDecisionInput, RetryExhaustedInput } from \"./types.js\";\n\n/**\n * Runs the throw-mode retry loop: throws `RetryError` on exhaustion and\n * `AbortError` when `signal` aborts.\n *\n * @param policy - Object providing `next` and `onExhausted` (same contract as\n *   `BaseRetryPolicy`).\n * @param execute - Async work callback per attempt.\n * @param sleep - Delay function between retries.\n * @param signal - Optional cancel signal.\n * @returns Resolves to the first successful return value.\n * @throws {RetryError} When retries are exhausted and `onExhausted` returns\n *   the terminal error.\n * @throws {AbortError} When `signal` is already aborted or aborts while waiting.\n * @throws Any error thrown by `next`, `onExhausted`, or `sleep`.\n */\nexport async function runThrowMode<T, TError, TData>(\n  policy: {\n    next: (input: RetryDecisionInput<TError, TData>) => RetryDecision;\n    onExhausted: (input: RetryExhaustedInput<TError, TData>) => RetryError;\n  },\n  execute: (attempt: number) => Promise<T>,\n  sleep: (delayMs: number) => Promise<void>,\n  signal?: AbortSignal,\n): Promise<T> {\n  let attempt = 1;\n\n  while (true) {\n    throwIfAborted(signal);\n\n    try {\n      return await execute(attempt);\n    } catch (error) {\n      throwIfAborted(signal);\n\n      const typedError = error as TError;\n      const decision = policy.next({\n        attempt,\n        error: typedError,\n      });\n\n      if (!decision.shouldRetry) {\n        throw policy.onExhausted({\n          attempts: attempt,\n          error: typedError,\n        });\n      }\n\n      if (decision.delayMs > 0) {\n        if (signal) {\n          await sleepWithAbortSignal(sleep, decision.delayMs, signal);\n        } else {\n          await sleep(decision.delayMs);\n        }\n      }\n\n      attempt += 1;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,eAAsB,aACpB,QAIA,SACA,OACA,QACY;CACZ,IAAI,UAAU;AAEd,QAAO,MAAM;AACX,iBAAe,OAAO;AAEtB,MAAI;AACF,UAAO,MAAM,QAAQ,QAAQ;WACtB,OAAO;AACd,kBAAe,OAAO;GAEtB,MAAM,aAAa;GACnB,MAAM,WAAW,OAAO,KAAK;IAC3B;IACA,OAAO;IACR,CAAC;AAEF,OAAI,CAAC,SAAS,YACZ,OAAM,OAAO,YAAY;IACvB,UAAU;IACV,OAAO;IACR,CAAC;AAGJ,OAAI,SAAS,UAAU,EACrB,KAAI,OACF,OAAM,qBAAqB,OAAO,SAAS,SAAS,OAAO;OAE3D,OAAM,MAAM,SAAS,QAAQ;AAIjC,cAAW"}
+{"version":3,"file":"throw-mode.mjs","names":[],"sources":["../src/throw-mode.ts"],"sourcesContent":["/**\n * Throw-mode execution path for `BaseRetryPolicy.run` (default when\n * `throwOnExhausted` is not `false`).\n *\n * @module @zap-studio/retry/throw-mode\n */\n\nimport { sleepWithAbortSignal, throwIfAborted } from \"./abort.js\";\nimport type { RetryPolicy } from \"./types.js\";\n\n/**\n * Runs the throw-mode retry loop: throws `RetryError` on exhaustion and\n * `AbortError` when `signal` aborts.\n *\n * @param policy - Object providing `next` and `onExhausted` (same contract as\n *   `BaseRetryPolicy`).\n * @param execute - Async work callback per attempt.\n * @param sleep - Delay function between retries.\n * @param signal - Optional cancel signal.\n * @returns Resolves to the first successful return value.\n * @throws {RetryError} When retries are exhausted and `onExhausted` returns\n *   the terminal error.\n * @throws {AbortError} When `signal` is already aborted or aborts while waiting.\n * @throws {Error} Any error thrown by `next`, `onExhausted`, or `sleep`.\n */\nexport const runThrowMode = async <T, TError, TData>(\n  policy: RetryPolicy<TError, TData>,\n  execute: (attempt: number) => Promise<T>,\n  sleep: (delayMs: number) => Promise<void>,\n  signal?: AbortSignal\n): Promise<T> => {\n  let attempt = 1;\n\n  while (true) {\n    throwIfAborted(signal);\n\n    try {\n      // oxlint-disable-next-line no-await-in-loop -- Retry attempts must run sequentially.\n      return await execute(attempt);\n    } catch (error) {\n      throwIfAborted(signal);\n\n      // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- Policy error generic represents the caller's thrown error domain.\n      const typedError = error as TError;\n      const decision = policy.next({\n        attempt,\n        error: typedError,\n      });\n\n      if (!decision.shouldRetry) {\n        throw policy.onExhausted({\n          attempts: attempt,\n          error: typedError,\n        });\n      }\n\n      if (decision.delayMs > 0) {\n        // oxlint-disable-next-line no-await-in-loop -- Delay belongs between sequential retry attempts.\n        await (signal === undefined\n          ? sleep(decision.delayMs)\n          : sleepWithAbortSignal(sleep, decision.delayMs, signal));\n      }\n\n      attempt += 1;\n    }\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,eAAe,OAC1B,QACA,SACA,OACA,WACe;CACf,IAAI,UAAU;CAEd,OAAO,MAAM;EACX,eAAe,MAAM;EAErB,IAAI;GAEF,OAAO,MAAM,QAAQ,OAAO;EAC9B,SAAS,OAAO;GACd,eAAe,MAAM;GAGrB,MAAM,aAAa;GACnB,MAAM,WAAW,OAAO,KAAK;IAC3B;IACA,OAAO;GACT,CAAC;GAED,IAAI,CAAC,SAAS,aACZ,MAAM,OAAO,YAAY;IACvB,UAAU;IACV,OAAO;GACT,CAAC;GAGH,IAAI,SAAS,UAAU,GAErB,OAAO,WAAW,KAAA,IACd,MAAM,SAAS,OAAO,IACtB,qBAAqB,OAAO,SAAS,SAAS,MAAM;GAG1D,WAAW;EACb;CACF;AACF"}

package/dist/types.d.mts

@@ -1,143 +1,141 @@
-import { r as RetryError, t as AbortError } from "./errors-fWo_KyVO.mjs";
-
+import { r as RetryError, t as AbortError } from "./errors-BVZjP1Q5.mjs";
 //#region src/types.d.ts
 /**
-* Retry policy contract used by `BaseRetryPolicy`.
-*
-* @example
-* const policy: RetryPolicy = {
-*   next: ({ attempt }) => ({ shouldRetry: attempt < 3, delayMs: 100 }),
-*   onExhausted: ({ attempts }) => new RetryError("done", { attempts }),
-* };
-*/
+ * Retry policy contract used by `BaseRetryPolicy`.
+ *
+ * @example
+ * const policy: RetryPolicy = {
+ *   next: ({ attempt }) => ({ shouldRetry: attempt < 3, delayMs: 100 }),
+ *   onExhausted: ({ attempts }) => new RetryError("done", { attempts }),
+ * };
+ */
 interface RetryPolicy<TError = unknown, TData = unknown> {
   /**
-  * Returns the retry decision for a failed attempt.
-  *
-  * @throws Any error thrown by the policy implementation.
-  */
-  next(input: RetryDecisionInput<TError, TData>): RetryDecision;
-  /**
-  * Builds the terminal error used when retries are exhausted.
-  *
-  * @throws Any error thrown by the policy implementation.
-  */
-  onExhausted(input: RetryExhaustedInput<TError, TData>): RetryError;
+   * Returns the retry decision for a failed attempt.
+   *
+   * @throws {Error} Any error thrown by the policy implementation.
+   */
+  next: (input: RetryDecisionInput<TError, TData>) => RetryDecision;
+  /**
+   * Builds the terminal error used when retries are exhausted.
+   *
+   * @throws {Error} Any error thrown by the policy implementation.
+   */
+  onExhausted: (input: RetryExhaustedInput<TError, TData>) => RetryError;
 }
 /**
-* Decision returned by a retry policy for a specific attempt.
-*/
+ * Decision returned by a retry policy for a specific attempt.
+ */
 interface RetryDecision {
   /**
-  * When `true`, the runner may schedule another attempt (subject to
-  * `delayMs` and the runner's abort rules).
-  */
+   * When `true`, the runner may schedule another attempt (subject to
+   * `delayMs` and the runner's abort rules).
+   */
   readonly shouldRetry: boolean;
   /**
-  * Milliseconds to wait before the next attempt when `shouldRetry` is `true`.
-  */
+   * Milliseconds to wait before the next attempt when `shouldRetry` is `true`.
+   */
   readonly delayMs: number;
   /**
-  * Optional machine-readable reason for the decision.
-  */
+   * Optional machine-readable reason for the decision.
+   */
   readonly reason?: "retry" | "max-attempts-reached" | "policy-declined";
 }
 /**
-* Input passed to `RetryPolicy.next(...)` for each failed attempt.
-*/
+ * Input passed to `RetryPolicy.next(...)` for each failed attempt.
+ */
 interface RetryDecisionInput<TError = unknown, TData = unknown> {
   /**
-  * One-based attempt number for the current failure.
-  */
+   * One-based attempt number for the current failure.
+   */
   readonly attempt: number;
   /**
-  * Optional policy-level maximum attempts, when a policy wants to pass it
-  * through to `next`.
-  */
+   * Optional policy-level maximum attempts, when a policy wants to pass it
+   * through to `next`.
+   */
   readonly maxAttempts?: number;
   /**
-  * Error raised by the most recent `execute(attempt)` call, when a failure
-  * occurred.
-  */
+   * Error raised by the most recent `execute(attempt)` call, when a failure
+   * occurred.
+   */
   readonly error?: TError;
   /**
-  * Optional data captured alongside the failure, when a policy populates
-  * it.
-  */
+   * Optional data captured alongside the failure, when a policy populates
+   * it.
+   */
   readonly data?: TData;
 }
 /**
-* Input passed to `RetryPolicy.onExhausted(...)` when retries stop.
-*/
+ * Input passed to `RetryPolicy.onExhausted(...)` when retries stop.
+ */
 interface RetryExhaustedInput<TError = unknown, TData = unknown> {
   /**
-  * Count of completed attempts that led to stopping retries.
-  */
+   * Count of completed attempts that led to stopping retries.
+   */
   readonly attempts: number;
   /**
-  * Last execution error, when available.
-  */
+   * Last execution error, when available.
+   */
   readonly error?: TError;
   /**
-  * Last captured data, when a policy or runner supplies it.
-  */
+   * Last captured data, when a policy or runner supplies it.
+   */
   readonly data?: TData;
 }
 /**
-* Options for `BaseRetryPolicy.run(...)`.
-*/
+ * Options for `BaseRetryPolicy.run(...)`.
+ */
 interface RetryRunOptions {
   /**
-  * Delay function used between retry attempts.
-  *
-  * @throws Any error thrown or rejected by the custom delay implementation.
-  */
+   * Delay function used between retry attempts.
+   *
+   * @throws {Error} Any error thrown or rejected by the custom delay implementation.
+   */
   readonly sleep?: (delayMs: number) => Promise<void>;
   /**
-  * Abort signal used to cancel retry orchestration.
-  *
-  * When aborted, the runner stops retrying and terminates immediately.
-  */
+   * Abort signal used to cancel retry orchestration.
+   *
+   * When aborted, the runner stops retrying and terminates immediately.
+   */
   readonly signal?: AbortSignal;
   /**
-  * When `true`, the runner throws a `RetryError` when retries are exhausted.
-  *
-  * When `false`, the runner returns a `RetryRunResult` discriminated union.
-  *
-  * @default true
-  */
+   * When `true`, the runner throws a `RetryError` when retries are exhausted.
+   *
+   * When `false`, the runner returns a `RetryRunResult` discriminated union.
+   *
+   * @default true
+   */
   readonly throwOnExhausted?: boolean;
 }
 /**
-* Result union returned by non-throw runner mode.
-*
-* - Success: `ok: true` with the resolved `value`.
-* - Failure: `ok: false` with terminal `error` and completed `attempts` count
-*   (exhaustion or abort).
-*/
+ * Result union returned by non-throw runner mode.
+ *
+ * - Success: `ok: true` with the resolved `value`.
+ * - Failure: `ok: false` with terminal `error` and completed `attempts` count
+ *   (exhaustion or abort).
+ */
 type RetryRunResult<T> = {
   /**
-  * Discriminator for a successful run.
-  */
+   * Discriminator for a successful run.
+   */
   ok: true;
   /**
-  * Successful return value from the final attempt.
-  */
+   * Successful return value from the final attempt.
+   */
   value: T;
 } | {
   /**
-  * Discriminator for a failed or aborted run.
-  */
+   * Discriminator for a failed or aborted run.
+   */
   ok: false;
   /**
-  * Terminal error: `RetryError` when retries are exhausted, or
-  * `AbortError` when the run is canceled (non-throw path uses the same
-  * instances as throw mode, not wrapped).
-  */
+   * Terminal error: `RetryError` when retries are exhausted, or
+   * `AbortError` when the run is canceled.
+   */
   error: RetryError | AbortError;
   /**
-  * Number of attempts that completed before the terminal outcome.
-  */
+   * Number of attempts that completed before the terminal outcome.
+   */
   attempts: number;
 };
 //#endregion

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;UAiBiB,WAAA;;;;;;EAMf,IAAA,CAAK,KAAA,EAAO,kBAAA,CAAmB,MAAA,EAAQ,KAAA,IAAS,aAAA;;;;;;EAMhD,WAAA,CAAY,KAAA,EAAO,mBAAA,CAAoB,MAAA,EAAQ,KAAA,IAAS,UAAA;AAAA;AAM1D;;;AAAA,UAAiB,aAAA;;;;;WAKN,WAAA;EAcX;;;EAAA,SAVW,OAAA;;;;WAIA,MAAA;AAAA;;;;UAMM,kBAAA;;;;WAIN,OAAA;;;;;WAKA,WAAA;;;AAkCX;;WA7BW,KAAA,GAAQ,MAAA;EAyCC;;;;EAAA,SApCT,IAAA,GAAO,KAAA;AAAA;;;;UAMD,mBAAA;;;;WAIN,QAAA;;;;WAIA,KAAA,GAAQ,MAAA;;;;WAIR,IAAA,GAAO,KAAA;AAAA;;;;UAMD,eAAA;;;;;;WAMN,KAAA,IAAS,OAAA,aAAoB,OAAA;;;;;;WAM7B,MAAA,GAAS,WAAA;;;;;;;;WAQT,gBAAA;AAAA;;;;;;;;KAUC,cAAA;;;;EAKN,EAAA;;;;EAIA,KAAA,EAAO,CAAA;AAAA;;;;EAMP,EAAA;;;;;;EAMA,KAAA,EAAO,UAAA,GAAa,UAAA;;;;EAIpB,QAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;UAiBiB,YAAY,kBAAkB;;;;;;EAM7C,OAAO,OAAO,mBAAmB,QAAQ,WAAW;;;;;;EAMpD,cAAc,OAAO,oBAAoB,QAAQ,WAAW;;;;;UAM7C;;;;;WAKN;;;;WAIA;;;;WAIA;;;;;UAMM,mBAAmB,kBAAkB;;;;WAI3C;;;;;WAKA;;;;;WAKA,QAAQ;;;;;WAKR,OAAO;;;;;UAMD,oBAAoB,kBAAkB;;;;WAI5C;;;;WAIA,QAAQ;;;;WAIR,OAAO;;;;;UAMD;;;;;;WAMN,SAAS,oBAAoB;;;;;;WAM7B,SAAS;;;;;;;;WAQT;;;;;;;;;KAUC,eAAe;;;;EAKrB;;;;EAIA,OAAO;;;;;EAMP;;;;;EAKA,OAAO,aAAa;;;;EAIpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-studio/retry",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "private": false,
   "description": "Composable retry policies for resilient async operations.",
   "keywords": [
@@ -50,16 +50,15 @@
     "exponential-backoff": "^3.1.3",
     "p-retry": "^8.0.0",
     "promise-retry": "^2.0.1",
-    "typescript": "^6.0.3",
-    "vite-plus": "^0.1.19",
+    "tsdown": "^0.22.4",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
     "@zap-studio/typescript": "0.0.0"
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "vp pack",
-    "test": "vp test run",
-    "test:watch": "vp test watch"
+    "build": "tsdown --config ./tsdown.config.ts"
   }
 }

package/dist/errors-fWo_KyVO.d.mts

@@ -1,76 +0,0 @@
-//#region src/errors.d.ts
-/**
-* Terminal error types used by retry policies and runners.
-*
-* @module @zap-studio/retry/errors
-*/
-/**
-* Context payload attached to `RetryError`.
-*/
-interface RetryErrorContext {
-  /**
-  * Count of completed attempts at exhaustion.
-  */
-  readonly attempts: number;
-  /**
-  * The last error object raised by a failed `execute` attempt.
-  */
-  readonly lastError?: unknown;
-  /**
-  * Optional data captured from the last attempt when provided by a policy.
-  */
-  readonly lastData?: unknown;
-}
-/**
-* Context payload attached to `AbortError`.
-*/
-interface AbortErrorContext {
-  /**
-  * When the abort `reason` was an `Error`, the optional wrapped cause.
-  */
-  readonly cause?: unknown;
-}
-/**
-* Error thrown when retries are exhausted.
-*
-* @example
-* throw new RetryError("Retry exhausted", {
-*   attempts: 3,
-*   lastError: new Error("network"),
-* });
-*/
-declare class RetryError extends Error {
-  /**
-  * Total attempts performed before exhaustion.
-  */
-  readonly attempts: number;
-  /**
-  * Last captured error from execution.
-  */
-  readonly lastError?: unknown;
-  /**
-  * Last captured data value, when available.
-  */
-  readonly lastData?: unknown;
-  /**
-  * Creates a RetryError with structured terminal context.
-  */
-  constructor(message: string, context: RetryErrorContext);
-}
-/**
-* Error thrown when retry orchestration is canceled through `AbortSignal`.
-*/
-declare class AbortError extends Error {
-  /**
-  * Optional wrapped cause when the native abort `reason` was an `Error`.
-  */
-  override readonly cause?: unknown;
-  /**
-  * @param message - Human-readable abort description.
-  * @param context - Optional `cause` link for diagnostic chaining.
-  */
-  constructor(message: string, context?: AbortErrorContext);
-}
-//#endregion
-export { RetryErrorContext as i, AbortErrorContext as n, RetryError as r, AbortError as t };
-//# sourceMappingURL=errors-fWo_KyVO.d.mts.map

package/dist/errors-fWo_KyVO.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-fWo_KyVO.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;AASA;;;;;;;UAAiB,iBAAA;EAYN;AAMX;;EANW,SARA,QAAA;EAcM;;AAgBjB;EAhBiB,SAVN,SAAA;;;;WAIA,QAAA;AAAA;;;;UAMM,iBAAA;;;;WAIN,KAAA;AAAA;;;;;;;;;;cAYE,UAAA,SAAmB,KAAA;;;;WAId,QAAA;;;;WAIA,SAAA;;;;WAIA,QAAA;;;;EAKhB,WAAA,CAAY,OAAA,UAAiB,OAAA,EAAS,iBAAA;AAAA;;;;cAY3B,UAAA,SAAmB,KAAA;;;;oBAIL,KAAA;;;;;EAMzB,WAAA,CAAY,OAAA,UAAiB,OAAA,GAAS,iBAAA;AAAA"}