@zap-studio/retry 0.3.0 → 0.3.2

package/dist/throw-mode.mjs.map

@@ -1 +0,0 @@
-{"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"}

package/dist/types.d.mts

@@ -1,145 +0,0 @@
-import { r as RetryError, t as AbortError } from "./errors-fWo_KyVO.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 }),
-* };
-*/
-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;
-}
-/**
-* 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).
-  */
-  readonly shouldRetry: boolean;
-  /**
-  * Milliseconds to wait before the next attempt when `shouldRetry` is `true`.
-  */
-  readonly delayMs: number;
-  /**
-  * Optional machine-readable reason for the decision.
-  */
-  readonly reason?: "retry" | "max-attempts-reached" | "policy-declined";
-}
-/**
-* Input passed to `RetryPolicy.next(...)` for each failed attempt.
-*/
-interface RetryDecisionInput<TError = unknown, TData = unknown> {
-  /**
-  * 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`.
-  */
-  readonly maxAttempts?: number;
-  /**
-  * 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.
-  */
-  readonly data?: TData;
-}
-/**
-* Input passed to `RetryPolicy.onExhausted(...)` when retries stop.
-*/
-interface RetryExhaustedInput<TError = unknown, TData = unknown> {
-  /**
-  * Count of completed attempts that led to stopping retries.
-  */
-  readonly attempts: number;
-  /**
-  * Last execution error, when available.
-  */
-  readonly error?: TError;
-  /**
-  * Last captured data, when a policy or runner supplies it.
-  */
-  readonly data?: TData;
-}
-/**
-* Options for `BaseRetryPolicy.run(...)`.
-*/
-interface RetryRunOptions {
-  /**
-  * Delay function used between retry attempts.
-  *
-  * @throws 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.
-  */
-  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
-  */
-  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).
-*/
-type RetryRunResult<T> = {
-  /**
-  * Discriminator for a successful run.
-  */
-  ok: true;
-  /**
-  * Successful return value from the final attempt.
-  */
-  value: T;
-} | {
-  /**
-  * 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).
-  */
-  error: RetryError | AbortError;
-  /**
-  * Number of attempts that completed before the terminal outcome.
-  */
-  attempts: number;
-};
-//#endregion
-export { RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryPolicy, RetryRunOptions, RetryRunResult };
-//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +0,0 @@
-{"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"}

package/dist/types.mjs

@@ -1 +0,0 @@
-export {};