websocket-ts 2.2.1 → 3.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Joscha Behrmann
+Copyright (c) 2020 Joscha Behrmann
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,30 +1,33 @@
-<div>
-  <div align="center">
-    <img src="https://raw.githubusercontent.com/jjxxs/websocket-ts/gh-pages/websocket-ts-logo.svg" alt="websocket-ts" width="300" height="65" />
-  </div>
-  <p align="center">
-    <img src="https://github.com/jjxxs/websocket-ts/actions/workflows/build.yml/badge.svg" alt="Build Status" />
-    <img src="https://github.com/jjxxs/websocket-ts/actions/workflows/test.yml/badge.svg" alt="Build Status" />
-    <a href="https://coveralls.io/github/jjxxs/websocket-ts?branch=master">
-      <img src="https://coveralls.io/repos/github/jjxxs/websocket-ts/badge.svg?branch=master&service=github" alt="Coverage Status" />
-    </a>
-    <a href="https://github.com/jjxxs/websocket-ts/releases/latest">
-      <img src="https://img.shields.io/github/v/release/jjxxs/websocket-ts" alt="Release" />
-    </a>
-    <a href="/LICENSE">
-      <img src="https://img.shields.io/github/license/jjxxs/websocket-ts" alt="License" />
-    </a>
-  </p>
+<div align="center">
+<img src="https://raw.githubusercontent.com/jjxxs/websocket-ts/gh-pages/websocket-ts-logo.svg" alt="websocket-ts" width="300" height="65" />
 </div>
-
+&nbsp;
 <div align="center">
 A <b>WebSocket</b> for browsers with <b>auto-reconnect</b> and <b>message buffering</b> written in <b>TypeScript</b>.
+</div>
+&nbsp;
+<div align="center">
+
+[![Build Status](https://img.shields.io/github/actions/workflow/status/jjxxs/websocket-ts/build.yml)](https://github.com/jjxxs/websocket-ts/actions/workflows/build.yml)
+[![Test Status](https://img.shields.io/github/actions/workflow/status/jjxxs/websocket-ts/test.yml?label=tests)](https://github.com/jjxxs/websocket-ts/actions/workflows/test.yml)
+[![Coverage Status](https://img.shields.io/coveralls/github/jjxxs/websocket-ts/main)](https://coveralls.io/github/jjxxs/websocket-ts?branch=main)
+[![npm downloads](https://img.shields.io/npm/dm/websocket-ts.svg)](https://npm-stat.com/charts.html?package=websocket-ts)
+
+</div>
+
+<div align="center">
+
+[![npm version](https://img.shields.io/npm/v/websocket-ts.svg)](https://www.npmjs.org/package/websocket-ts)
+[![Bundle Size](https://deno.bundlejs.com/badge?q=websocket-ts)](https://bundlejs.com/?q=websocket-ts)
+[![Snyk security](https://snyk.io/test/npm/websocket-ts/badge.svg)](https://snyk.io/test/npm/websocket-ts)
+[![License](https://img.shields.io/npm/l/websocket-ts)](https://github.com/jjxxs/websocket-ts/blob/main/LICENSE)
+
 </div>
 
 ## Features
 
-- **Lightweight & Standalone**: No dependencies, 2.1 kB minified & gzipped.
-- **Browser-native**: Utilizes WebSocket API, offers direct access.
+- **Lightweight & Standalone**: No dependencies, only a few kB minified & gzipped (see badge).
+- **Browser-native**: Utilizes native WebSocket API, offers direct access to the underlying connection.
 - **Smart Reconnect**: Optional auto-reconnect and message buffering.
 - **Easy Setup**: Optional builder class for quick initialization.
 - **Well-Tested**: High test coverage, well-documented for extensibility.
@@ -35,11 +38,11 @@ A <b>WebSocket</b> for browsers with <b>auto-reconnect</b> and <b>message buffer
 Install `websocket-ts` with npm:
 
 ```bash
-$ npm install websocket-ts 
+npm install websocket-ts
 ```
 
 ## Quickstart
-This example shows how to use the package, complete with message buffering and automatic reconnection.
+This example creates a WebSocket with message buffering and automatic reconnection.
 The created websocket will echo back any received messages. It will buffer messages when disconnected
 and attempt to reconnect every 1 second.
 
@@ -71,7 +74,7 @@ ws.addEventListener(WebsocketEvent.message, echoOnMessage);
 ```
 
 ## Usage
-This will demonstrate how to use `websocket-ts` in your project using the provided `WebsocketBuild`-class.
+This section demonstrates how to use `websocket-ts` in your project using the provided `WebsocketBuilder` class.
 
 For a more detailed description of the API, please refer to the [API Documentation](https://jjxxs.github.io/websocket-ts/).
 
@@ -85,36 +88,71 @@ const ws = new WebsocketBuilder("ws://localhost:42421").build();
 
 #### Events
 
-There are six events which can be subscribed to through with event listeners:
+There are seven events you can listen for:
+
+| Event | Description |
+|---|---|
+| `open` | Connection opened |
+| `close` | Connection closed |
+| `error` | An error occurred |
+| `message` | Message received |
+| `retry` | Reconnect attempt |
+| `reconnect` | Automatic retry succeeded (fires before `open`) |
+| `exhausted` | Gave up reconnecting after `maxRetries` consecutive failed attempts |
+
+You can use either `WebsocketEvent.open` or the string `"open"` when registering listeners.
+
+The `retry`, `reconnect` and `exhausted` events are `CustomEvent`s whose `detail`
+carries the number of retries and the time of the last successful connection.
+
+The browser's own `error` events carry no details. When an automatic retry
+fails because the URL provider or the `WebSocket` constructor threw, the
+`error` event is an `ErrorEvent` whose `error` is the thrown value:
 
 ```typescript
-export enum WebsocketEvent {
-  open = "open",          // Connection opened
-  close = "close",        // Connection closed
-  error = "error",        // Error-induced closure
-  message = "message",    // Message received
-  retry = "retry",        // Reconnect attempt
-  reconnect = "reconnect" // Successful reconnect
-}
+ws.addEventListener(WebsocketEvent.error, (i, ev) => {
+  if (ev instanceof ErrorEvent) {
+    console.warn("connection attempt failed", ev.error);
+  }
+});
 ```
 
+Errors thrown by the `WebSocket` constructor may include the URL in their
+message, so take care when forwarding them to logs if the URL contains a token.
+
 #### Add Event Listeners
 Event listeners receive the websocket instance (`i`) and the triggering event (`ev`) as arguments.
 
- ```typescript
- const ws = new WebsocketBuilder("ws://localhost:42421")
-   .onOpen((i, ev) => console.log("opened"))
-   .onClose((i, ev) => console.log("closed"))
-   .onError((i, ev) => console.log("error"))
-   .onMessage((i, ev) => console.log("message"))
-   .onRetry((i, ev) => console.log("retry"))
-   .onReconnect((i, ev) => console.log("reconnect"))
-   .build();
- ```
+```typescript
+const ws = new WebsocketBuilder("ws://localhost:42421")
+  .onOpen((i, ev) => console.log("opened"))
+  .onClose((i, ev) => console.log("closed"))
+  .onError((i, ev) => console.log("error"))
+  .onMessage((i, ev) => console.log("message"))
+  .onRetry((i, ev) => console.log("retry"))
+  .onReconnect((i, ev) => console.log("reconnect"))
+  .onExhausted((i, ev) => console.log("gave up"))
+  .build();
+```
+
+Listeners accept the options `once` (remove after the first call) and `signal`
+(an `AbortSignal`). Aborting the signal removes the listener again, which is
+handy for tearing down a group of listeners in one call, e.g. when a component
+unmounts:
+
+```typescript
+const controller = new AbortController();
+ws.addEventListener(WebsocketEvent.message, onMessage, { signal: controller.signal });
+ws.addEventListener(WebsocketEvent.close, onClose, { signal: controller.signal });
+/* ... on teardown: */
+controller.abort(); // removes both listeners
+```
 
 #### Remove Event Listeners
 
-To unregister a specific event listener, use `removeEventListener`:
+To unregister a specific event listener, use `removeEventListener`. Listeners
+are matched by function identity; the options they were registered with are
+ignored when matching:
 
 ```typescript
 let ws: Websocket
@@ -132,15 +170,20 @@ let ws: Websocket;
 ws.send("Hello World!");
 ```
 
+If the websocket is not connected, the message is stored in the buffer and
+sent once the connection is (re-)established — but only if a buffer was
+configured (see below). Without a buffer, or after `close()` was called, the
+message is silently dropped.
+
 #### Reconnect & Backoff (Optional)
 
-If you'd like the websocket to automatically reconnect upon disconnection, you can optionally provide a `Backoff` strategy. 
-This sets the delay between reconnection attempts. There are three built-in `Backoff` implementations, or you can create 
-your own by implementing the `Backoff` interface. If no Backoff is provided, the websocket will not attempt to reconnect.
+To automatically reconnect after a disconnection, provide a `Backoff` strategy.
+This controls the delay between reconnection attempts. There are three built-in `Backoff` implementations, or you can create
+your own by implementing the `Backoff` interface. If no backoff is provided, the websocket will not attempt to reconnect.
 
 ##### ConstantBackoff
 
-The `ConstantBackoff` strategy enforces a fixed delay between each reconnection attempt. 
+`ConstantBackoff` uses a fixed delay between each reconnection attempt.
 To set a constant 1-second wait time, use:
 
 ```typescript
@@ -149,11 +192,11 @@ const ws = new WebsocketBuilder("ws://localhost:42421")
   .build();
 ```
 
-##### LinearBackoff
+#### LinearBackoff
 
-The `LinearBackoff` strategy increases the delay between reconnection attempts linearly,
+`LinearBackoff` increases the delay between reconnection attempts linearly,
 up to an optional maximum. For example, to start with a 0-second delay and increase by
-10 second for each retry, capping at 60 seconds, use:
+10 seconds for each retry, capping at 60 seconds, use:
 
 ```typescript
 const ws = new WebsocketBuilder("ws://localhost:42421")
@@ -163,9 +206,9 @@ const ws = new WebsocketBuilder("ws://localhost:42421")
 
 ##### ExponentialBackoff
 
-The `ExponentialBackoff` strategy doubles the delay between each reconnection attempt, up
+`ExponentialBackoff` doubles the delay between each reconnection attempt, up
 to a specified maximum. This approach is inspired by the binary exponential backoff algorithm
-commonly used in networking. For example, to generate a backoff series like `[1s, 2s, 4s, 8s]`, use:
+commonly used in networking. For example, to use a base of 1000ms with a maximum exponent of 6:
 
 ```typescript
 const ws = new WebsocketBuilder("ws://localhost:42421")
@@ -173,20 +216,66 @@ const ws = new WebsocketBuilder("ws://localhost:42421")
   .build();
 ```
 
+##### Retry Limit & Instant Reconnect
+
+Two options refine the retry behavior. Both require a backoff to be
+configured — setting them without one throws at construction:
+
+- `withMaxRetries(n)` stops reconnecting after `n` consecutive failed
+  attempts. The counter resets on every successful reconnect, so the limit
+  applies per outage, not per websocket lifetime. When the limit is reached,
+  the `exhausted` event fires.
+- `withInstantReconnect(true)` skips the backoff delay for the *first* retry
+  of an outage — useful when a dropped connection is usually recoverable
+  immediately (e.g. a server restart). Subsequent retries follow the backoff.
+
+```typescript
+const ws = new WebsocketBuilder("ws://localhost:42421")
+  .withBackoff(new ExponentialBackoff(1000, 6))
+  .withMaxRetries(10)          // give up after 10 consecutive failures
+  .withInstantReconnect(true)  // first retry of an outage is instant
+  .build();
+```
+
+##### Giving Up & Resuming
+
+When `maxRetries` is exhausted, the websocket stops retrying and fires the
+`exhausted` event. Use `reconnect()` to resume — it resets the retry budget,
+resolves the URL (provider) again and connects immediately. It also works on
+an open or user-closed websocket, e.g. to force a new connection after an
+auth-token rotation or when the browser comes back online:
+
+```typescript
+const ws = new WebsocketBuilder("ws://localhost:42421")
+  .withBackoff(new ConstantBackoff(1000))
+  .withMaxRetries(5)
+  .onExhausted(() => showReconnectBanner())
+  .build();
+
+reconnectButton.onclick = () => ws.reconnect();
+window.addEventListener("online", () => ws.reconnect());
+```
+
 #### Buffer (Optional)
 
-To buffer outgoing messages when the websocket is disconnected, you can optionally specify
-a `Queue`. This queue will temporarily store your messages and send them in sequence when
+To buffer outgoing messages when the websocket is disconnected, provide a `Queue`.
+The queue temporarily stores messages and sends them in order when
 the websocket (re)connects. Two built-in `Queue` implementations are available, or you can
-create your own by implementing the `Queue` interface. If no queue is provided, messages 
+create your own by implementing the `Queue` interface. If no queue is provided, messages
 won't be buffered.
 
+The buffer only covers the time the websocket is not open: a message handed to an open
+connection is not buffered again, so it is lost if the connection drops before it arrives.
+If you need guaranteed delivery, add acknowledgements at the application level.
+
+Buffered messages are kept when you call `close()` and are sent once `reconnect()` opens a
+new connection, even if the URL provider now returns a URL for a different user. At such a
+boundary, clear the queue you passed in (e.g. `queue.clear()`) or create a new websocket.
+
 ##### RingQueue
 
-The `RingQueue` is a fixed-capacity, first-in-first-out (FIFO) queue. When it reaches capacity, 
-the oldest element is removed to accommodate new ones. Reading from the queue returns and
-removes the oldest element. For instance, to set up a `RingQueue` with a 100-element capacity,
-use:
+`RingQueue` is a fixed-capacity, first-in-first-out (FIFO) queue. When it reaches capacity,
+the oldest element is removed to make room for new ones. For instance, to set up a `RingQueue` with a 100-element capacity:
 
 ```typescript
 const ws = new WebsocketBuilder("ws://localhost:42421")
@@ -196,8 +285,8 @@ const ws = new WebsocketBuilder("ws://localhost:42421")
 
 ##### ArrayQueue
 
-The ArrayQueue offers an unbounded capacity, functioning as a first-in-first-out (FIFO) queue. 
-Reading from this queue returns and removes the oldest element. To use an `ArrayQueue`, use:
+`ArrayQueue` is an unbounded first-in-first-out (FIFO) queue.
+To use an `ArrayQueue`:
 
 ```typescript
 const ws = new WebsocketBuilder("ws://localhost:42421")
@@ -205,8 +294,57 @@ const ws = new WebsocketBuilder("ws://localhost:42421")
   .build();
 ```
 
+#### URL Provider (Optional)
+
+By default, the URL is a static string. To use a different URL between connection attempts, provide
+a function instead. The function is called on each connection attempt, including the initial one and
+any retries, and should only resolve a URL. This enables use cases like load balancing, auth token
+rotation, and failover.
+
+```typescript
+const ws = new WebsocketBuilder(() => `ws://localhost:42421?token=${getToken()}`)
+  .withBackoff(new ConstantBackoff(1000))
+  .build();
+```
+
+Calling `reconnect()` also re-runs the provider, so a fresh URL (e.g. a new
+token) can be forced without waiting for the connection to drop.
+
+If the provider throws during an automatic retry, the websocket fires an
+`error` event carrying the thrown value (see [Events](#events)) and keeps
+retrying under the usual backoff and `maxRetries` rules. When called from the
+constructor or `reconnect()`, the exception propagates to the caller.
+
+## Upgrading from 2.x
+
+- **Imports**: import from `websocket-ts` only. Deep imports such as
+  `websocket-ts/dist/cjs/src/...` no longer resolve.
+- **JavaScript target**: the published code is ES2018 (2.x shipped ES5/ES2015).
+  Transpile it yourself if you support older browsers.
+- **Retry options**: setting `maxRetries` or `instantReconnect` (even to `false`)
+  without a backoff now throws, as does a `maxRetries` that is neither a whole
+  number ≥ 0 nor `Infinity`.
+- **`instantReconnect`**: only the first retry of an outage is instant; later
+  retries follow the backoff and count towards `maxRetries`. In 2.x every retry
+  was instant and `maxRetries` was ignored.
+- **Backoff**: the first retry now waits the first value of the series, as
+  documented, e.g. `ExponentialBackoff(1000)` waits 1s, 2s, 4s, … (2.x: 2s, 4s, …).
+  Custom `Backoff`s must return `current` from `next()` and then advance.
+- **`reconnect` event**: fires (before `open`) whenever an automatic retry
+  succeeds, now also if the initial connection failed. A manual `reconnect()`
+  only fires `open`, so put (re-)subscription logic into `open`.
+- **URL provider errors**: an exception from the provider (or the `WebSocket`
+  constructor) during an automatic retry no longer escapes as an uncaught
+  error that stops reconnecting. It is delivered as an `error` event (an
+  `ErrorEvent` carrying the thrown value), and retrying continues.
+- **Listeners**: options are limited to `once` and `signal`.
+  `removeEventListener` removes every registration of the given function,
+  regardless of its options.
+- **Types**: `send()` and buffers accept `string | Blob | BufferSource`;
+  `SharedArrayBuffer`-backed data is no longer accepted.
+
 ## Build & Tests
 
-To compile the project, execute `npm run build`. 
+To compile the project, run `npm run build`.
 
-To run tests, use `npm run test`.
+To run tests, use `npm run test`.

package/dist/cjs/{src/backoff → backoff}/backoff.d.ts

@@ -1,6 +1,9 @@
 /**
  * A Backoff produces a series of numbers that are used to determine
  * the delay between connection-retries. Values are expected to be in milliseconds.
+ *
+ * Implementations must not call back into the websocket (e.g. close() or reconnect()):
+ * the websocket calls them in the middle of its lifecycle transitions.
  */
 export interface Backoff {
     /**
@@ -8,12 +11,12 @@ export interface Backoff {
      */
     readonly retries: number;
     /**
-     * Current number in the series.
+     * Current number in the series, i.e. the value that the next call to next() will return.
      */
     readonly current: number;
     /**
-     * Advances the series to the next number and returns it.
-     * @return the next number in the series
+     * Returns the current number in the series and advances the series by one step.
+     * @return the current number in the series
      */
     next(): number;
     /**

package/dist/{esm/src → cjs}/backoff/backoff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../../../src/backoff/backoff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,IAAI,IAAI,MAAM,CAAC;IAEf;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;CACf"}
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../../src/backoff/backoff.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,IAAI,IAAI,MAAM,CAAC;IAEf;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;CACf"}

package/dist/{esm/src → cjs}/backoff/backoff.js.map

@@ -1 +1 @@
-{"version":3,"file":"backoff.js","sourceRoot":"","sources":["../../../../src/backoff/backoff.ts"],"names":[],"mappings":""}
+{"version":3,"file":"backoff.js","sourceRoot":"","sources":["../../../src/backoff/backoff.ts"],"names":[],"mappings":""}

package/dist/cjs/{src/backoff → backoff}/constantbackoff.d.ts

@@ -1,4 +1,4 @@
-import { Backoff } from "./backoff";
+import { Backoff } from "./backoff.js";
 /**
  * ConstantBackoff always returns the same backoff-time.
  */
@@ -7,7 +7,7 @@ export declare class ConstantBackoff implements Backoff {
     private _retries;
     /**
      * Creates a new ConstantBackoff.
-     * @param backoff the backoff-time to return
+     * @param backoff the backoff-time (in milliseconds) to return
      */
     constructor(backoff: number);
     get retries(): number;

package/dist/cjs/backoff/constantbackoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constantbackoff.d.ts","sourceRoot":"","sources":["../../../src/backoff/constantbackoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;GAEG;AACH,qBAAa,eAAgB,YAAW,OAAO;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAa;IAE7B;;;OAGG;gBACS,OAAO,EAAE,MAAM;IAQ3B,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,IAAI,MAAM;IAKd,KAAK,IAAI,IAAI;CAGd"}

package/dist/cjs/backoff/constantbackoff.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantBackoff = void 0;
+/**
+ * ConstantBackoff always returns the same backoff-time.
+ */
+class ConstantBackoff {
+    /**
+     * Creates a new ConstantBackoff.
+     * @param backoff the backoff-time (in milliseconds) to return
+     */
+    constructor(backoff) {
+        this._retries = 0;
+        if (!Number.isFinite(backoff) || backoff < 0) {
+            throw new Error("Backoff must be a finite, non-negative number");
+        }
+        this.backoff = backoff;
+    }
+    get retries() {
+        return this._retries;
+    }
+    get current() {
+        return this.backoff;
+    }
+    next() {
+        this._retries++;
+        return this.backoff;
+    }
+    reset() {
+        this._retries = 0;
+    }
+}
+exports.ConstantBackoff = ConstantBackoff;
+//# sourceMappingURL=constantbackoff.js.map

package/dist/cjs/backoff/constantbackoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constantbackoff.js","sourceRoot":"","sources":["../../../src/backoff/constantbackoff.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACH,MAAa,eAAe;IAI1B;;;OAGG;IACH,YAAY,OAAe;QANnB,aAAQ,GAAW,CAAC,CAAC;QAO3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,IAAI;QACF,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IACpB,CAAC;CACF;AAhCD,0CAgCC"}

package/dist/{esm/src → cjs}/backoff/exponentialbackoff.d.ts

@@ -1,4 +1,4 @@
-import { Backoff } from "./backoff";
+import { Backoff } from "./backoff.js";
 /**
  * ExponentialBackoff increases the backoff-time exponentially.
  * An optional maximum can be provided as an upper bound to the
@@ -36,7 +36,7 @@ export declare class ExponentialBackoff implements Backoff {
     private _retries;
     /**
      * Creates a new ExponentialBackoff.
-     * @param base the base of the exponentiation
+     * @param base the base of the exponentiation (in milliseconds)
      * @param expMax the maximum exponent, no bound if undefined
      */
     constructor(base: number, expMax?: number);

package/dist/cjs/backoff/exponentialbackoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialbackoff.d.ts","sourceRoot":"","sources":["../../../src/backoff/exponentialbackoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,kBAAmB,YAAW,OAAO;IAChD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,CAAC,CAAS;IAClB,OAAO,CAAC,QAAQ,CAAa;IAE7B;;;;OAIG;gBACS,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAazC,IAAI,OAAO,WAEV;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,IAAI,MAAM;IAUd,KAAK,IAAI,IAAI;CAId"}

package/dist/cjs/{src/backoff → backoff}/exponentialbackoff.js

@@ -31,51 +31,43 @@ exports.ExponentialBackoff = void 0;
  *  backoff = 1000 * 2^3 = 8000
  *  ... // and so on
  */
-var ExponentialBackoff = /** @class */ (function () {
+class ExponentialBackoff {
     /**
      * Creates a new ExponentialBackoff.
-     * @param base the base of the exponentiation
+     * @param base the base of the exponentiation (in milliseconds)
      * @param expMax the maximum exponent, no bound if undefined
      */
-    function ExponentialBackoff(base, expMax) {
+    constructor(base, expMax) {
         this._retries = 0;
-        if (!Number.isInteger(base) || base < 0) {
-            throw new Error("Base must be a positive integer or zero");
+        if (!Number.isFinite(base) || base < 0) {
+            throw new Error("Base must be a finite, non-negative number");
         }
         if (expMax !== undefined && (!Number.isInteger(expMax) || expMax < 0)) {
-            throw new Error("ExpMax must be a undefined, a positive integer or zero");
+            throw new Error("ExpMax must be undefined or a non-negative integer");
         }
         this.base = base;
         this.expMax = expMax;
         this.i = 0;
     }
-    Object.defineProperty(ExponentialBackoff.prototype, "retries", {
-        get: function () {
-            return this._retries;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ExponentialBackoff.prototype, "current", {
-        get: function () {
-            return this.base * Math.pow(2, this.i);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ExponentialBackoff.prototype.next = function () {
+    get retries() {
+        return this._retries;
+    }
+    get current() {
+        return this.base * Math.pow(2, this.i);
+    }
+    next() {
+        const backoff = this.current;
         this._retries++;
         this.i =
             this.expMax === undefined
                 ? this.i + 1
                 : Math.min(this.i + 1, this.expMax);
-        return this.current;
-    };
-    ExponentialBackoff.prototype.reset = function () {
+        return backoff;
+    }
+    reset() {
         this._retries = 0;
         this.i = 0;
-    };
-    return ExponentialBackoff;
-}());
+    }
+}
 exports.ExponentialBackoff = ExponentialBackoff;
 //# sourceMappingURL=exponentialbackoff.js.map

package/dist/cjs/backoff/exponentialbackoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialbackoff.js","sourceRoot":"","sources":["../../../src/backoff/exponentialbackoff.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAa,kBAAkB;IAM7B;;;;OAIG;IACH,YAAY,IAAY,EAAE,MAAe;QAPjC,aAAQ,GAAW,CAAC,CAAC;QAQ3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;QACD,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC;YACtE,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAED,IAAI;QACF,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC,CAAC;YACJ,IAAI,CAAC,MAAM,KAAK,SAAS;gBACvB,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC;gBACZ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACxC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;CACF;AA9CD,gDA8CC"}

package/dist/{esm/src → cjs}/backoff/linearbackoff.d.ts

@@ -1,4 +1,4 @@
-import { Backoff } from "./backoff";
+import { Backoff } from "./backoff.js";
 /**
  * LinearBackoff returns a backoff-time that is incremented by a fixed amount
  * with every step/retry. An optional maximum can be provided as an upper bound

package/dist/cjs/backoff/linearbackoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linearbackoff.d.ts","sourceRoot":"","sources":["../../../src/backoff/linearbackoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,aAAc,YAAW,OAAO;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAS;IAC9B,OAAO,CAAC,CAAC,CAAa;IACtB,OAAO,CAAC,QAAQ,CAAa;IAE7B;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAqB5D,IAAI,OAAO,WAEV;IAED,IAAI,OAAO,IAAI,MAAM,CAIpB;IAED,IAAI,IAAI,MAAM;IAOd,KAAK,IAAI,IAAI;CAId"}