Formatting

source/exponential-backoff.ts

@@ -76,7 +76,7 @@ export class ExponentialBackoff {
      * @param options.baseDelay - Delay used as the basis for the first retry. Default: `1_000` ms.
      * @param options.growthRate - Multiplier applied to the delay after each attempt. Default: `2`.
      * @param options.jitter - Maximum proportional reduction subtracted from each delay (0–1). Default: `0.1`.
-     * 
+     *
      * @throws An {@link ExponentialBackoffNumberNotFiniteError} if a provided option is not a finite number
      * @throws An {@link ExponentialBackoffNumberOutOfBoundsError} if a provided option is out of bounds
      * @throws An {@link ExponentialBackoffNumberTooSmallError} if a provided option is too small
@@ -99,6 +99,12 @@ export class ExponentialBackoff {
      * Create a new ExponentialBackoff instance
      *
      * @param config - The configuration for the exponential backoff
+     *
+     * @throws An {@link ExponentialBackoffNumberNotFiniteError} if a provided option is not a finite number
+     * @throws An {@link ExponentialBackoffNumberOutOfBoundsError} if a provided option is out of bounds
+     * @throws An {@link ExponentialBackoffNumberTooSmallError} if a provided option is too small
+     * @throws An {@link ExponentialBackoffNonIntegerError} if a provided option is not an integer
+     *
      * @returns The ExponentialBackoff instance
      */
     public static from(config?: Partial<ExponentialBackoffOptions>): ExponentialBackoff {

source/misc.ts

@@ -8,9 +8,9 @@
  * @returns True if the value is within the bounds, false otherwise
  */
 export const isWithinBounds = (value: number, min: number, max: number): boolean => {
-  if (value < min || value > max) {
+    if (value < min || value > max) {
-    return false;
+        return false;
-  }
+    }
 
-  return true;
+    return true;
-};
+};

test/exponential-backoff.test.ts

@@ -1,6 +1,10 @@
 import { expect, test, vi } from 'vitest';
 import { ExponentialBackoff } from '../source/exponential-backoff.ts';
-import { ExponentialBackoffMaxRetriesHitError, ExponentialBackoffNumberNotFiniteError, ExponentialBackoffStoppedRetriesError } from '../source/errors.ts';
+import {
+    ExponentialBackoffMaxRetriesHitError,
+    ExponentialBackoffNumberNotFiniteError,
+    ExponentialBackoffStoppedRetriesError,
+} from '../source/errors.ts';
 
 /**
  * A valid options object that satisfies {@link ExponentialBackoff.validateOptions}.
@@ -589,13 +593,16 @@ const testExponentialBackoffCalculateDelayDoesNotResultInNaN = (): void => {
     const largeNumber = 1_000_000_000_000;
 
     // Test the calculateDelay function
-    const result = ExponentialBackoff.calculateDelay({
+    const result = ExponentialBackoff.calculateDelay(
-        baseDelay: 10000,
+        {
-        growthRate: largeNumber,
+            baseDelay: 10000,
-        jitter: 0,
+            growthRate: largeNumber,
-        maxDelay: 10_000,
+            jitter: 0,
-        maxAttempts: largeNumber,
+            maxDelay: 10_000,
-    }, largeNumber);
+            maxAttempts: largeNumber,
+        },
+        largeNumber,
+    );
 
     // Test to ensure it was bounded to the max delay
     expect(result).toBe(10_000);
@@ -615,6 +622,7 @@ const testExponentialBackoffConstructorDoesNotCauseErrorDuringSpread = async ():
     // @ts-expect-error - Passing undefined is allowed if the exactOptionalPropertyTypes option is set to false in TS Compiler options.
     expect(() => new ExponentialBackoff(options)).toThrow(ExponentialBackoffNumberNotFiniteError);
 };
+
 const runTests = async (): Promise<void> => {
     test('ExponentialBackoff.run: delegates to a new instance using default options', testExponentialBackoffRunUsesDefaultOptions);
     test('ExponentialBackoff.run: retries and succeeds with partial options', testExponentialBackoffRunWithPartialOptions);
@@ -641,7 +649,10 @@ const runTests = async (): Promise<void> => {
     test('ExponentialBackoff.validateOptions: rejects Infinity', testExponentialBackoffValidateOptionsRejectsNonFiniteValues);
     test('ExponentialBackoff.validateOptions: rejects non-integer values', testExponentialBackoffValidateOptionsRejectsNonIntegerValues);
     test('ExponentialBackoff.validateOptions: rejects NaN', testExponentialBackoffValidateOptionsRejectsNaN);
-    test('ExponentialBackoff: calculateDelay does not result in NaN from extremely large growth rates and attempts', testExponentialBackoffCalculateDelayDoesNotResultInNaN);
+    test(
+        'ExponentialBackoff: calculateDelay does not result in NaN from extremely large growth rates and attempts',
+        testExponentialBackoffCalculateDelayDoesNotResultInNaN,
+    );
     test('ExponentialBackoff: constructor does not cause an error during spread', testExponentialBackoffConstructorDoesNotCauseErrorDuringSpread);
 };