feat(linked-list): Add EmptyAwareSinglyLinkedList and enhance DoublyLinkedList functionality

- Introduced `EmptyAwareSinglyLinkedList`, a subclass of `SinglyLinkedList` that emits an `empty` event when the list becomes empty due to `reset`, `shift`, or `remove` operations.
- Added `nodes()` iterator method to `DoublyLinkedList` for iterating over nodes directly.
- Enhanced unit tests for `DoublyLinkedList` and `SinglyLinkedList` to cover edge cases and new functionality.
- Added comprehensive tests for `EmptyAwareSinglyLinkedList` to validate `empty` event emission under various scenarios.
- Improved code formatting and consistency.

Author: nkaradzhov

packages/client/lib/client/linked-list.spec.ts

@@ -1,138 +1,197 @@
-import { SinglyLinkedList, DoublyLinkedList } from './linked-list';
-import { equal, deepEqual } from 'assert/strict';
-
-describe('DoublyLinkedList', () => {
+import {
+  SinglyLinkedList,
+  DoublyLinkedList,
+  EmptyAwareSinglyLinkedList,
+} from "./linked-list";
+import { equal, deepEqual } from "assert/strict";
+
+describe("DoublyLinkedList", () => {
   const list = new DoublyLinkedList();
 
-  it('should start empty', () => {
+  it("should start empty", () => {
     equal(list.length, 0);
     equal(list.head, undefined);
     equal(list.tail, undefined);
     deepEqual(Array.from(list), []);
   });
 
-  it('shift empty', () => {
+  it("shift empty", () => {
     equal(list.shift(), undefined);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
 
-  it('push 1', () => {
+  it("push 1", () => {
     list.push(1);
     equal(list.length, 1);
     deepEqual(Array.from(list), [1]);
   });
 
-  it('push 2', () => {
+  it("push 2", () => {
     list.push(2);
     equal(list.length, 2);
     deepEqual(Array.from(list), [1, 2]);
   });
 
-  it('unshift 0', () => {
+  it("unshift 0", () => {
     list.unshift(0);
     equal(list.length, 3);
     deepEqual(Array.from(list), [0, 1, 2]);
   });
 
-  it('remove middle node', () => {
+  it("remove middle node", () => {
     list.remove(list.head!.next!);
     equal(list.length, 2);
     deepEqual(Array.from(list), [0, 2]);
   });
 
-  it('remove head', () => {
+  it("remove head", () => {
     list.remove(list.head!);
     equal(list.length, 1);
     deepEqual(Array.from(list), [2]);
   });
 
-  it('remove tail', () => {
+  it("remove tail", () => {
     list.remove(list.tail!);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
 
-  it('unshift empty queue', () => {
+  it("unshift empty queue", () => {
     list.unshift(0);
     equal(list.length, 1);
     deepEqual(Array.from(list), [0]);
   });
 
-  it('push 1', () => {
+  it("push 1", () => {
     list.push(1);
     equal(list.length, 2);
     deepEqual(Array.from(list), [0, 1]);
   });
 
-  it('shift', () => {
+  it("shift", () => {
     equal(list.shift(), 0);
     equal(list.length, 1);
     deepEqual(Array.from(list), [1]);
   });
 
-  it('shift last element', () => {
+  it("shift last element", () => {
     equal(list.shift(), 1);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
+
+  it("provide forEach for nodes", () => {
+    list.reset();
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    let count = 0;
+    for(const _ of list.nodes()) {
+      count++;
+    }
+    equal(count, 3);
+    for(const _ of list.nodes()) {
+      count++;
+    }
+    equal(count, 6);
+  });
 });
 
-describe('SinglyLinkedList', () => {
+describe("SinglyLinkedList", () => {
   const list = new SinglyLinkedList();
 
-  it('should start empty', () => {
+  it("should start empty", () => {
     equal(list.length, 0);
     equal(list.head, undefined);
     equal(list.tail, undefined);
     deepEqual(Array.from(list), []);
   });
 
-  it('shift empty', () => {
+  it("shift empty", () => {
     equal(list.shift(), undefined);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
 
-  it('push 1', () => {
+  it("push 1", () => {
     list.push(1);
     equal(list.length, 1);
     deepEqual(Array.from(list), [1]);
   });
 
-  it('push 2', () => {
+  it("push 2", () => {
     list.push(2);
     equal(list.length, 2);
     deepEqual(Array.from(list), [1, 2]);
   });
 
-  it('push 3', () => {
+  it("push 3", () => {
     list.push(3);
     equal(list.length, 3);
     deepEqual(Array.from(list), [1, 2, 3]);
   });
 
-  it('shift 1', () => {
+  it("shift 1", () => {
     equal(list.shift(), 1);
     equal(list.length, 2);
     deepEqual(Array.from(list), [2, 3]);
   });
 
-  it('shift 2', () => {
+  it("shift 2", () => {
     equal(list.shift(), 2);
     equal(list.length, 1);
     deepEqual(Array.from(list), [3]);
   });
 
-  it('shift 3', () => {
+  it("shift 3", () => {
     equal(list.shift(), 3);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
 
-  it('should be empty', () => {
+  it("should be empty", () => {
     equal(list.length, 0);
     equal(list.head, undefined);
     equal(list.tail, undefined);
   });
 });
+
+describe("EmptyAwareSinglyLinkedList", () => {
+  it("should emit 'empty' event when reset", () => {
+    const list = new EmptyAwareSinglyLinkedList<number>();
+    let count = 0;
+    list.events.on("empty", () => count++);
+    list.push(1);
+    list.reset();
+    equal(count, 1);
+    list.reset();
+    equal(count, 1);
+  });
+
+  it("should emit 'empty' event when shift makes the list empty", () => {
+    const list = new EmptyAwareSinglyLinkedList<number>();
+    let count = 0;
+    list.events.on("empty", () => count++);
+    list.push(1);
+    list.push(2);
+    list.shift();
+    equal(count, 0);
+    list.shift();
+    equal(count, 1);
+    list.shift();
+    equal(count, 1);
+  });
+
+  it("should emit 'empty' event when remove makes the list empty", () => {
+    const list = new EmptyAwareSinglyLinkedList<number>();
+    let count = 0;
+    list.events.on("empty", () => count++);
+    const node1 = list.push(1);
+    const node2 = list.push(2);
+    list.remove(node1, undefined);
+    equal(count, 0);
+    list.remove(node2, undefined);
+    equal(count, 1);
+  });
+});

packages/client/lib/client/linked-list.ts

@@ -1,3 +1,5 @@
+import EventEmitter from "events";
+
 export interface DoublyLinkedNode<T> {
   value: T;
   previous: DoublyLinkedNode<T> | undefined;
@@ -32,7 +34,7 @@ export class DoublyLinkedList<T> {
         next: undefined,
         value
       };
-    } 
+    }
 
     return this.#tail = this.#tail.next = {
       previous: this.#tail,
@@ -93,7 +95,7 @@ export class DoublyLinkedList<T> {
       node.previous!.next = node.next;
       node.previous = undefined;
     }
-    
+
     node.next = undefined;
   }
 
@@ -109,6 +111,14 @@ export class DoublyLinkedList<T> {
       node = node.next;
     }
   }
+
+  *nodes() {
+    let node = this.#head;
+    while(node) {
+      yield node;
+      node = node.next;
+    }
+  }
 }
 
 export interface SinglyLinkedNode<T> {
@@ -201,3 +211,30 @@ export class SinglyLinkedList<T> {
     }
   }
 }
+
+export class EmptyAwareSinglyLinkedList<T> extends SinglyLinkedList<T> {
+  readonly events = new EventEmitter();
+  reset() {
+    const old = this.length;
+    super.reset();
+    if(old !== this.length && this.length === 0) {
+      this.events.emit('empty');
+    }
+  }
+  shift(): T | undefined {
+    const old = this.length;
+    const ret = super.shift();
+    if(old !== this.length && this.length === 0) {
+      this.events.emit('empty');
+    }
+    return ret;
+  }
+  remove(node: SinglyLinkedNode<T>, parent: SinglyLinkedNode<T> | undefined) {
+    const old = this.length;
+    super.remove(node, parent);
+    if(old !== this.length && this.length === 0) {
+      this.events.emit('empty');
+    }
+  }
+
+}