websocket-ts 2.2.1 → 3.0.0

package/src/index.ts

@@ -1,23 +1,24 @@
-export { Backoff } from "./backoff/backoff";
-export { ConstantBackoff } from "./backoff/constantbackoff";
-export { ExponentialBackoff } from "./backoff/exponentialbackoff";
-export { LinearBackoff } from "./backoff/linearbackoff";
-export { Queue } from "./queue/queue";
-export { ArrayQueue } from "./queue/array_queue";
-export { RingQueue } from "./queue/ring_queue";
-export { Websocket } from "./websocket";
-export { WebsocketBuffer } from "./websocket_buffer";
-export { WebsocketBuilder } from "./websocket_builder";
+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";
-export { WebsocketOptions } from "./websocket_options";
-export { WebsocketConnectionRetryOptions } from "./websocket_retry_options";
+} from "./websocket_event.js";
+export { WebsocketOptions } from "./websocket_options.js";
+export { WebsocketConnectionRetryOptions } from "./websocket_retry_options.js";

package/src/queue/array_queue.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

package/src/queue/ring_queue.ts

@@ -1,4 +1,4 @@
-import { Queue } from "./queue";
+import { Queue } from "./queue.js";
 
 /**
  * A ring queue is a queue that has a fixed capacity. When the queue is full, the oldest element is
@@ -6,7 +6,7 @@ import { Queue } from "./queue";
  * element and effectively remove it from the queue.
  */
 export class RingQueue<E> implements Queue<E> {
-  private readonly elements: E[];
+  private readonly elements: (E | undefined)[]; // unoccupied positions hold undefined so read elements can be garbage-collected
   private head: number; // index of the next position to write to
   private tail: number; // index of the next position to read from
 
@@ -15,7 +15,7 @@ export class RingQueue<E> implements Queue<E> {
       throw new Error("Capacity must be a positive integer");
     }
 
-    this.elements = new Array<E>(capacity + 1); // +1 to distinguish between full and empty
+    this.elements = new Array<E | undefined>(capacity + 1); // +1 to distinguish between full and empty
     this.head = 0;
     this.tail = 0;
   }
@@ -24,11 +24,13 @@ export class RingQueue<E> implements Queue<E> {
     this.elements[this.head] = element;
     this.head = (this.head + 1) % this.elements.length;
     if (this.head === this.tail) {
+      this.elements[this.tail] = undefined; // drop the reference of the overwritten oldest element
       this.tail = (this.tail + 1) % this.elements.length;
     }
   }
 
   clear() {
+    this.elements.fill(undefined); // drop all references so elements can be garbage-collected
     this.head = 0;
     this.tail = 0;
   }
@@ -39,7 +41,7 @@ export class RingQueue<E> implements Queue<E> {
       i !== this.head;
       i = (i + 1) % this.elements.length
     ) {
-      fn(this.elements[i]);
+      fn(this.elements[i] as E);
     }
   }
 
@@ -56,14 +58,16 @@ export class RingQueue<E> implements Queue<E> {
   }
 
   peek(): E | undefined {
-    return this.isEmpty() ? undefined : this.elements[this.tail];
+    return this.isEmpty() ? undefined : (this.elements[this.tail] as E);
   }
 
   read(): E | undefined {
-    const e = this.peek();
-    if (e !== undefined) {
-      this.tail = (this.tail + 1) % this.elements.length;
+    if (this.isEmpty()) {
+      return undefined; // empty is determined by the indices, so stored 'undefined' elements read correctly
     }
+    const e = this.elements[this.tail] as E;
+    this.elements[this.tail] = undefined; // drop the reference so the element can be garbage-collected
+    this.tail = (this.tail + 1) % this.elements.length;
     return e;
   }
 }