websocket-ts 2.3.0 → 3.0.0

package/README.md

@@ -10,7 +10,7 @@ A <b>WebSocket</b> for browsers with <b>auto-reconnect</b> and <b>message buffer
 
 [![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/master)](https://coveralls.io/github/jjxxs/websocket-ts?branch=master)
+[![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>
@@ -18,15 +18,15 @@ A <b>WebSocket</b> for browsers with <b>auto-reconnect</b> and <b>message buffer
 <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@2.2.1)](https://bundlejs.com/?q=websocket-ts)
-[![Known Vulnerabilities](https://snyk.io/test/npm/websocket-ts/badge.svg)](https://snyk.io/test/npm/websocket-ts)
-[![License](https://img.shields.io/github/license/jjxxs/websocket-ts)](/LICENSE)
+[![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.5 kB minified & gzipped.
+- **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.
@@ -88,7 +88,7 @@ const ws = new WebsocketBuilder("ws://localhost:42421").build();
 
 #### Events
 
-There are six events you can listen for:
+There are seven events you can listen for:
 
 | Event | Description |
 |---|---|
@@ -97,10 +97,29 @@ There are six events you can listen for:
 | `error` | An error occurred |
 | `message` | Message received |
 | `retry` | Reconnect attempt |
-| `reconnect` | Successful reconnect |
+| `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
+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.
 
@@ -112,12 +131,28 @@ const ws = new WebsocketBuilder("ws://localhost:42421")
   .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
@@ -135,6 +170,11 @@ 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)
 
 To automatically reconnect after a disconnection, provide a `Backoff` strategy.
@@ -176,6 +216,46 @@ 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, provide a `Queue`.
@@ -184,6 +264,14 @@ the websocket (re)connects. Two built-in `Queue` implementations are available,
 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
 
 `RingQueue` is a fixed-capacity, first-in-first-out (FIFO) queue. When it reaches capacity,
@@ -210,7 +298,8 @@ const ws = new WebsocketBuilder("ws://localhost:42421")
 
 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. This enables use cases like load balancing, auth token rotation, and failover.
+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()}`)
@@ -218,6 +307,42 @@ const ws = new WebsocketBuilder(() => `ws://localhost:42421?token=${getToken()}`
   .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, run `npm run build`.

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 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"}

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

@@ -32,24 +32,24 @@ exports.LinearBackoff = void 0;
  *  backoff = 1000 + 1000 * 4 = 5000
  *  ... // and so on
  */
-var LinearBackoff = /** @class */ (function () {
+class LinearBackoff {
     /**
      * Creates a new LinearBackoff.
      * @param initial the initial backoff-time in milliseconds
      * @param increment the amount to increment the backoff-time with every step (in milliseconds)
      * @param max the maximum backoff-time (in milliseconds), no bound if undefined
      */
-    function LinearBackoff(initial, increment, max) {
+    constructor(initial, increment, max) {
         this.i = 0;
         this._retries = 0;
-        if (initial < 0) {
-            throw new Error("Initial must be a positive number or zero");
+        if (!Number.isFinite(initial) || initial < 0) {
+            throw new Error("Initial must be a finite, non-negative number");
         }
-        if (increment < 0) {
-            throw new Error("Increment must be a positive number or zero");
+        if (!Number.isFinite(increment) || increment < 0) {
+            throw new Error("Increment must be a finite, non-negative number");
         }
-        if (max !== undefined && max < 0) {
-            throw new Error("Max must be undefined, a positive number or zero");
+        if (max !== undefined && (!Number.isFinite(max) || max < 0)) {
+            throw new Error("Max must be undefined or a finite, non-negative number");
         }
         if (max !== undefined && max < initial) {
             throw new Error("Max must be undefined or greater than or equal to initial");
@@ -58,32 +58,24 @@ var LinearBackoff = /** @class */ (function () {
         this.increment = increment;
         this.max = max;
     }
-    Object.defineProperty(LinearBackoff.prototype, "retries", {
-        get: function () {
-            return this._retries;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(LinearBackoff.prototype, "current", {
-        get: function () {
-            return this.max === undefined
-                ? this.initial + this.increment * this.i
-                : Math.min(this.initial + this.increment * this.i, this.max);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    LinearBackoff.prototype.next = function () {
+    get retries() {
+        return this._retries;
+    }
+    get current() {
+        return this.max === undefined
+            ? this.initial + this.increment * this.i
+            : Math.min(this.initial + this.increment * this.i, this.max);
+    }
+    next() {
+        const backoff = this.current;
         this._retries++;
         this.i++;
-        return this.current;
-    };
-    LinearBackoff.prototype.reset = function () {
+        return backoff;
+    }
+    reset() {
         this._retries = 0;
         this.i = 0;
-    };
-    return LinearBackoff;
-}());
+    }
+}
 exports.LinearBackoff = LinearBackoff;
 //# sourceMappingURL=linearbackoff.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linearbackoff.js","sourceRoot":"","sources":["../../../src/backoff/linearbackoff.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAa,aAAa;IAOxB;;;;;OAKG;IACH,YAAY,OAAe,EAAE,SAAiB,EAAE,GAAY;QATpD,MAAC,GAAW,CAAC,CAAC;QACd,aAAQ,GAAW,CAAC,CAAC;QAS3B,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;QACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACrE,CAAC;QACD,IAAI,GAAG,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC;YAC5D,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5E,CAAC;QACD,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,GAAG,OAAO,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,GAAG,KAAK,SAAS;YAC3B,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;YACxC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;IACjE,CAAC;IAED,IAAI;QACF,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC,CAAC,EAAE,CAAC;QACT,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;CACF;AAvDD,sCAuDC"}

package/dist/cjs/index.d.ts

@@ -0,0 +1,14 @@
+export { Backoff } from "./backoff/backoff.js";
+export { ConstantBackoff } from "./backoff/constantbackoff.js";
+export { ExponentialBackoff } from "./backoff/exponentialbackoff.js";
+export { LinearBackoff } from "./backoff/linearbackoff.js";
+export { Queue } from "./queue/queue.js";
+export { ArrayQueue } from "./queue/array_queue.js";
+export { RingQueue } from "./queue/ring_queue.js";
+export { UrlProvider, Websocket } from "./websocket.js";
+export { WebsocketBuffer } from "./websocket_buffer.js";
+export { WebsocketBuilder } from "./websocket_builder.js";
+export { WebsocketEvent, RetryEventDetail, ReconnectEventDetail, ExhaustedEventDetail, WebsocketEventMap, WebsocketEventListener, WebsocketEventListenerParams, WebsocketEventListenerOptions, WebsocketEventListenerWithOptions, WebsocketEventListeners, } from "./websocket_event.js";
+export { WebsocketOptions } from "./websocket_options.js";
+export { WebsocketConnectionRetryOptions } from "./websocket_retry_options.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,sBAAsB,EACtB,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,uBAAuB,GACxB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,+BAA+B,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketEvent = exports.WebsocketBuilder = exports.Websocket = exports.RingQueue = exports.ArrayQueue = exports.LinearBackoff = exports.ExponentialBackoff = exports.ConstantBackoff = void 0;
+var constantbackoff_js_1 = require("./backoff/constantbackoff.js");
+Object.defineProperty(exports, "ConstantBackoff", { enumerable: true, get: function () { return constantbackoff_js_1.ConstantBackoff; } });
+var exponentialbackoff_js_1 = require("./backoff/exponentialbackoff.js");
+Object.defineProperty(exports, "ExponentialBackoff", { enumerable: true, get: function () { return exponentialbackoff_js_1.ExponentialBackoff; } });
+var linearbackoff_js_1 = require("./backoff/linearbackoff.js");
+Object.defineProperty(exports, "LinearBackoff", { enumerable: true, get: function () { return linearbackoff_js_1.LinearBackoff; } });
+var array_queue_js_1 = require("./queue/array_queue.js");
+Object.defineProperty(exports, "ArrayQueue", { enumerable: true, get: function () { return array_queue_js_1.ArrayQueue; } });
+var ring_queue_js_1 = require("./queue/ring_queue.js");
+Object.defineProperty(exports, "RingQueue", { enumerable: true, get: function () { return ring_queue_js_1.RingQueue; } });
+var websocket_js_1 = require("./websocket.js");
+Object.defineProperty(exports, "Websocket", { enumerable: true, get: function () { return websocket_js_1.Websocket; } });
+var websocket_builder_js_1 = require("./websocket_builder.js");
+Object.defineProperty(exports, "WebsocketBuilder", { enumerable: true, get: function () { return websocket_builder_js_1.WebsocketBuilder; } });
+var websocket_event_js_1 = require("./websocket_event.js");
+Object.defineProperty(exports, "WebsocketEvent", { enumerable: true, get: function () { return websocket_event_js_1.WebsocketEvent; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AACA,mEAA+D;AAAtD,qHAAA,eAAe,OAAA;AACxB,yEAAqE;AAA5D,2HAAA,kBAAkB,OAAA;AAC3B,+DAA2D;AAAlD,iHAAA,aAAa,OAAA;AAEtB,yDAAoD;AAA3C,4GAAA,UAAU,OAAA;AACnB,uDAAkD;AAAzC,0GAAA,SAAS,OAAA;AAClB,+CAAwD;AAAlC,yGAAA,SAAS,OAAA;AAE/B,+DAA0D;AAAjD,wHAAA,gBAAgB,OAAA;AACzB,2DAW8B;AAV5B,oHAAA,cAAc,OAAA"}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/{esm/src → cjs}/queue/array_queue.d.ts

@@ -1,4 +1,4 @@
-import { Queue } from "./queue";
+import { Queue } from "./queue.js";
 /**
  * An array queue is a queue that has an unbounded capacity. Reading from an array queue
  * will return the oldest element and effectively remove it from the queue.

package/dist/cjs/queue/array_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_queue.d.ts","sourceRoot":"","sources":["../../../src/queue/array_queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;GAGG;AACH,qBAAa,UAAU,CAAC,CAAC,CAAE,YAAW,KAAK,CAAC,CAAC,CAAC;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAM;;IAM/B,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAIrB,KAAK;IAIL,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO;IAInC,MAAM,IAAI,MAAM;IAIhB,OAAO,IAAI,OAAO;IAIlB,IAAI,IAAI,CAAC,GAAG,SAAS;IAIrB,IAAI,IAAI,CAAC,GAAG,SAAS;CAGtB"}

package/dist/cjs/{src/queue → queue}/array_queue.js

@@ -5,32 +5,31 @@ exports.ArrayQueue = void 0;
  * An array queue is a queue that has an unbounded capacity. Reading from an array queue
  * will return the oldest element and effectively remove it from the queue.
  */
-var ArrayQueue = /** @class */ (function () {
-    function ArrayQueue() {
+class ArrayQueue {
+    constructor() {
         this.elements = [];
     }
-    ArrayQueue.prototype.add = function (element) {
+    add(element) {
         this.elements.push(element);
-    };
-    ArrayQueue.prototype.clear = function () {
+    }
+    clear() {
         this.elements.length = 0;
-    };
-    ArrayQueue.prototype.forEach = function (fn) {
+    }
+    forEach(fn) {
         this.elements.forEach(fn);
-    };
-    ArrayQueue.prototype.length = function () {
+    }
+    length() {
         return this.elements.length;
-    };
-    ArrayQueue.prototype.isEmpty = function () {
+    }
+    isEmpty() {
         return this.elements.length === 0;
-    };
-    ArrayQueue.prototype.peek = function () {
+    }
+    peek() {
         return this.elements[0];
-    };
-    ArrayQueue.prototype.read = function () {
+    }
+    read() {
         return this.elements.shift();
-    };
-    return ArrayQueue;
-}());
+    }
+}
 exports.ArrayQueue = ArrayQueue;
 //# sourceMappingURL=array_queue.js.map

package/dist/cjs/queue/array_queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_queue.js","sourceRoot":"","sources":["../../../src/queue/array_queue.ts"],"names":[],"mappings":";;;AAEA;;;GAGG;AACH,MAAa,UAAU;IAGrB;QACE,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,GAAG,CAAC,OAAU;QACZ,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,OAAO,CAAC,EAA2B;QACjC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;IAC9B,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC1B,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;CACF;AAlCD,gCAkCC"}

package/dist/cjs/queue/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/queue/queue.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB;;;OAGG;IACH,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;IAEtB;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;OAGG;IACH,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC;IAE3C;;;OAGG;IACH,MAAM,IAAI,MAAM,CAAC;IAEjB;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC;IAEnB;;;OAGG;IACH,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC;IAEtB;;;OAGG;IACH,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC;CACvB"}

package/dist/cjs/{src/queue → queue}/queue.js.map

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