data-structure-typed 2.0.5 → 2.1.1

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BST, BSTNode, Range } from '../../../../src';
+import { BinaryTreeNode, BST, BSTNode, IBinaryTree, Range } from '../../../../src';
 import { isDebugTest, isTestStackOverflow, SYSTEM_MAX_CALL_STACK } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -331,8 +331,7 @@ describe('BST operations test', () => {
     if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
 
     expect(objBST.isAVLBalanced()).toBe(true);
-
-    expect(node15 && objBST.getHeight(node15)).toBe(2);
+    expect(node15 && objBST.getHeight(node15)).toBe(1);
 
     const removed1 = objBST.delete(1);
     expect(removed1).toBeInstanceOf(Array);
@@ -775,7 +774,7 @@ describe('BST operations test recursively', () => {
 
     expect(objBST.isAVLBalanced()).toBe(true);
 
-    expect(node15 && objBST.getHeight(node15)).toBe(2);
+    expect(node15 && objBST.getHeight(node15)).toBe(1);
 
     const removed1 = objBST.delete(1);
     expect(removed1).toBeInstanceOf(Array);
@@ -932,7 +931,7 @@ describe('BST operations test recursively', () => {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(bst: BST<string, number>) {
+    function checkTreeStructure(bst: IBinaryTree<string, number>) {
       expect(bst.size).toBe(4);
       expect(bst.root?.key).toBe('2');
       expect(bst.root?.left?.key).toBe('1');
@@ -1540,13 +1539,13 @@ describe('BST iterative methods not map mode test', () => {
 describe('BST constructor and comparator edge cases', () => {
   it('should support specifyComparable and isReverse', () => {
     const bst = new BST<number>([], {
-      specifyComparable: (k) => -k,
+      specifyComparable: k => -k,
       isReverse: true
     });
     bst.add(1);
     bst.add(2);
     expect(bst.isReverse).toBe(true);
-    expect(bst["_specifyComparable"]).toBeDefined();
+    expect(bst['_specifyComparable']).toBeDefined();
     expect([...bst.keys()]).toEqual([2, 1]);
   });
 
@@ -1563,7 +1562,11 @@ describe('BST addMany edge cases', () => {
     const values = ['a', 'b', 'c'];
     const result = bst.addMany(keys, values);
     expect(result).toEqual([true, true, true]);
-    expect([...bst]).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+    expect([...bst]).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   it('should addMany with isBalanceAdd=false', () => {
@@ -1608,7 +1611,7 @@ describe('BST _keyValueNodeOrEntryToNodeAndValue edge', () => {
   it('should return [undefined, undefined] for null', () => {
     const bst = new BST<number>();
     // @ts-ignore
-    const result = bst["_keyValueNodeOrEntryToNodeAndValue"](null);
+    const result = bst['_keyValueNodeOrEntryToNodeAndValue'](null);
     expect(result).toEqual([undefined, undefined]);
   });
 });

package/test/unit/data-structures/binary-tree/red-black-tree.test.ts

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, IBinaryTree, RedBlackTree, RedBlackTreeNode } from '../../../../src';
 import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
 import { OrderedMap } from 'js-sdsl';
 
@@ -148,7 +148,7 @@ describe('RedBlackTree 1', () => {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(rbTree: RedBlackTree<string, number>) {
+    function checkTreeStructure(rbTree: IBinaryTree<string, number>) {
       expect(rbTree.size).toBe(4);
       expect(rbTree.root?.key).toBe('2');
       expect(rbTree.root?.left?.key).toBe('1');

package/test/unit/data-structures/binary-tree/tree-counter.test.ts

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, RedBlackTreeNode, TreeCounter, TreeCounterNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, IBinaryTree, RedBlackTreeNode, TreeCounter, TreeCounterNode } from '../../../../src';
 import { isDebugTest } from '../../../config';
 import { getRandomInt } from '../../../utils';
 
@@ -172,12 +172,12 @@ describe('TreeCounter operations test1', () => {
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
     expect(treeCounter.isPerfectlyBalanced()).toBe(false);
     treeCounter.perfectlyBalance();
-    expect(treeCounter.isPerfectlyBalanced()).toBe(false);
+    expect(treeCounter.isPerfectlyBalanced()).toBe(true);
 
-    expect(treeCounter.isAVLBalanced()).toBe(false);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
 
     const bfsNodesAfterBalanced = treeCounter.bfs(node => node);
-    expect(bfsNodesAfterBalanced[0].key).toBe(6);
+    expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
     const removed11 = treeCounter.delete(11, true);
@@ -187,7 +187,7 @@ describe('TreeCounter operations test1', () => {
 
     if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
 
-    expect(treeCounter.isAVLBalanced()).toBe(false);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
 
     expect(treeCounter.getHeight(15)).toBe(1);
 
@@ -197,9 +197,9 @@ describe('TreeCounter operations test1', () => {
     expect(removed1[0].deleted);
     if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
 
-    expect(treeCounter.isAVLBalanced()).toBe(false);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
 
-    expect(treeCounter.getHeight()).toBe(5);
+    expect(treeCounter.getHeight()).toBe(4);
 
     const removed4 = treeCounter.delete(4, true);
     expect(removed4 instanceof Array);
@@ -207,8 +207,8 @@ describe('TreeCounter operations test1', () => {
     expect(removed4[0].deleted);
     if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
 
-    expect(treeCounter.isAVLBalanced()).toBe(false);
-    expect(treeCounter.getHeight()).toBe(5);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
+    expect(treeCounter.getHeight()).toBe(4);
 
     const removed10 = treeCounter.delete(10, true);
     expect(removed10 instanceof Array);
@@ -225,7 +225,7 @@ describe('TreeCounter operations test1', () => {
     expect(removed15[0].deleted);
     if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
 
-    expect(treeCounter.isAVLBalanced()).toBe(false);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
     expect(treeCounter.getHeight()).toBe(3);
 
     const removed5 = treeCounter.delete(5, true);
@@ -250,7 +250,7 @@ describe('TreeCounter operations test1', () => {
     expect(removed3[0]);
     expect(removed3[0].deleted);
     if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
-    expect(treeCounter.isAVLBalanced()).toBe(false);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
     expect(treeCounter.getHeight()).toBe(3);
 
     const removed8 = treeCounter.delete(8, true);
@@ -440,11 +440,11 @@ describe('TreeCounter operations test recursively1', () => {
 
     treeCounter.perfectlyBalance();
 
-    expect(treeCounter.isPerfectlyBalanced()).toBe(false);
-    expect(treeCounter.isAVLBalanced()).toBe(false);
+    expect(treeCounter.isPerfectlyBalanced()).toBe(true);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
 
     const bfsNodesAfterBalanced = treeCounter.bfs(node => node);
-    expect(bfsNodesAfterBalanced[0].key).toBe(6);
+    expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
     const removed11 = treeCounter.delete(11, true);
@@ -454,7 +454,7 @@ describe('TreeCounter operations test recursively1', () => {
 
     if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
 
-    expect(treeCounter.isAVLBalanced()).toBe(false);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
 
     expect(treeCounter.getHeight(15)).toBe(1);
 
@@ -463,10 +463,9 @@ describe('TreeCounter operations test recursively1', () => {
     expect(removed1[0]);
     expect(removed1[0].deleted);
     if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
 
-    expect(treeCounter.isAVLBalanced()).toBe(false);
-
-    expect(treeCounter.getHeight()).toBe(5);
+    expect(treeCounter.getHeight()).toBe(4);
 
     const removed4 = treeCounter.delete(4, true);
     expect(removed4 instanceof Array);
@@ -474,8 +473,8 @@ describe('TreeCounter operations test recursively1', () => {
     expect(removed4[0].deleted);
     if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
 
-    expect(treeCounter.isAVLBalanced()).toBe(false);
-    expect(treeCounter.getHeight()).toBe(5);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
+    expect(treeCounter.getHeight()).toBe(4);
 
     const removed10 = treeCounter.delete(10, true);
     expect(removed10 instanceof Array);
@@ -492,7 +491,7 @@ describe('TreeCounter operations test recursively1', () => {
     expect(removed15[0].deleted);
     if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
 
-    expect(treeCounter.isAVLBalanced()).toBe(false);
+    expect(treeCounter.isAVLBalanced()).toBe(true);
     expect(treeCounter.getHeight()).toBe(3);
 
     const removed5 = treeCounter.delete(5, true);
@@ -517,7 +516,8 @@ describe('TreeCounter operations test recursively1', () => {
     expect(removed3[0]);
     expect(removed3[0].deleted);
     if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
-    expect(treeCounter.isAVLBalanced()).toBe(false);
+
+    expect(treeCounter.isAVLBalanced()).toBe(true);
     expect(treeCounter.getHeight()).toBe(3);
 
     const removed8 = treeCounter.delete(8, true);
@@ -709,7 +709,7 @@ describe('TreeCounter delete test', function () {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(treeCounter: TreeCounter<string, number>) {
+    function checkTreeStructure(treeCounter: IBinaryTree<string, number>) {
       expect(treeCounter.size).toBe(4);
       expect(treeCounter.root?.key).toBe('2');
       expect(treeCounter.root?.left?.key).toBe('1');
@@ -969,7 +969,8 @@ describe('TreeCounter iterative methods test not map mode', () => {
     expect(treeCounter.count).toBe(21);
     expect(treeCounter.getComputedCount()).toBe(21);
     const cloned = treeCounter.clone();
+    expect(cloned instanceof TreeCounter).toBe(true);
     expect(cloned.root?.left?.key).toBe(1);
-    expect(cloned.get(cloned.root?.right)).toBe(undefined);
+    expect(cloned.get(cloned.root?.right)).toBe('c');
   });
 });

package/test/unit/data-structures/binary-tree/tree-multi-map.test.ts

@@ -1,6 +1,6 @@
-import { BinaryTreeNode, BSTNode, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, IBinaryTree, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
 import { getRandomInt } from '../../../utils';
-
+import { Range } from '../../../../src';
 import { isDebugTest } from '../../../config';
 import { costOfLiving } from './data/cost-of-living-by-country';
 
@@ -163,7 +163,7 @@ describe('TreeMultiMap 1', () => {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(tmm: TreeMultiMap<string, number>) {
+    function checkTreeStructure(tmm: IBinaryTree<string, number[]>) {
       expect(tmm.size).toBe(4);
       expect(tmm.root?.key).toBe('2');
       expect(tmm.root?.left?.key).toBe('1');
@@ -627,7 +627,7 @@ describe('TreeMultiMap 2', () => {
   });
 
   describe('TreeMultiMap iterative methods test', () => {
-    let tmm: TreeMultiMap<number, string, object, string, string, object>;
+    let tmm: TreeMultiMap<number, string, object>;
     beforeEach(() => {
       tmm = new TreeMultiMap();
       tmm.add([1, ['a']]);
@@ -1003,3 +1003,111 @@ describe('classic use', () => {
     ]);
   });
 });
+
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+}
+
+// Build a TreeMultiMap in "multi" mode: price -> Product[]
+function buildIndex(sample: Product[]): TreeMultiMap<number, Product, Product> {
+  return new TreeMultiMap<number, Product, Product>(sample, {
+    toEntryFn: raw => [raw.price, [raw]],
+    isMapMode: false // ensure multi-value per key
+  });
+}
+
+// Helper: normalize getLeftMost/getRightMost return (key or node.key)
+function leftKey(tmm: TreeMultiMap<number, Product, Product>): number | undefined {
+  const v = tmm.getLeftMost();
+  return v == null ? undefined : typeof v === 'object' ? v.key : v;
+}
+function rightKey(tmm: TreeMultiMap<number, Product, Product>): number | undefined {
+  const v = tmm.getRightMost();
+  return v == null ? undefined : typeof v === 'object' ? v.key : v;
+}
+
+describe('TreeMultiMap — rangeSearch-driven semantics', () => {
+  const sample: Product[] = [
+    { id: 'p1', name: 'Basic Tee', price: 35.5 },
+    { id: 'p2', name: 'Sport Socks', price: 12.9 },
+    { id: 'p3', name: 'Denim Jeans', price: 79.9 },
+    { id: 'p4', name: 'Hoodie', price: 79.9 },
+    { id: 'p5', name: 'Sneakers', price: 99.0 },
+    { id: 'p6', name: 'Backpack', price: 120.0 },
+    { id: 'p7', name: 'Watch', price: 199.0 },
+    { id: 'p8', name: 'Hat', price: 35.5 }
+  ];
+
+  it('stores multiple values under the same key and preserves insertion order in the bucket', () => {
+    const tmm = buildIndex(sample);
+    // Use rangeSearch on the single key [35.5, 35.5]
+    const groups = tmm.rangeSearch(new Range(35.5, 35.5, true, true), node => node.value).flat();
+    expect(groups.map(p => p!.id)).toEqual(['p1', 'p8']); // insertion order kept
+  });
+
+  it('iterates keys in ascending order (via keys())', () => {
+    const tmm = buildIndex(sample);
+    expect([...tmm.keys()]).toEqual([12.9, 35.5, 79.9, 99, 120, 199]);
+  });
+
+  it('rangeSearch respects inclusive/exclusive bounds — flat result', () => {
+    const tmm = buildIndex(sample);
+
+    // [35.5, 100): include 35.5, exclude 100
+    const res = tmm.rangeSearch(new Range(35.5, 100, true, false), node => node.value).flat();
+
+    expect(res.map(p => `${p!.name}($${p!.price})`)).toEqual([
+      'Basic Tee($35.5)',
+      'Hat($35.5)',
+      'Denim Jeans($79.9)',
+      'Hoodie($79.9)',
+      'Sneakers($99)'
+    ]);
+    expect(res.map(p => p!.id)).toEqual(['p1', 'p8', 'p3', 'p4', 'p5']);
+  });
+
+  it('rangeSearch returns grouped buckets — both ends exclusive', () => {
+    const tmm = buildIndex(sample);
+
+    // (80, 200) → keys 99, 120, 199
+    const groups = tmm.rangeSearch(new Range(80, 200, false, false), node => ({ key: node.key, bucket: node.value }));
+
+    expect(groups.map(g => g.key)).toEqual([99, 120, 199]);
+    expect(groups.map(g => g.bucket!.map(i => i.id))).toEqual([['p5'], ['p6'], ['p7']]);
+  });
+
+  it('rangeSearch across full domain by using current min/max keys (no Infinity)', () => {
+    const tmm = buildIndex(sample);
+    const lo = tmm.getLeftMost(); // expected 12.9
+    const hi = tmm.getRightMost(); // expected 199
+
+    const groups = tmm.rangeSearch(new Range(lo, hi, true, true), node => ({
+      key: node.key,
+      count: node.value!.length
+    }));
+
+    // 12.9:1 | 35.5:2 | 79.9:2 | 99:1 | 120:1 | 199:1
+    expect(groups.map(g => `${g.key}:${g.count}`).join(' | ')).toBe('12.9:1 | 35.5:2 | 79.9:2 | 99:1 | 120:1 | 199:1');
+  });
+
+  it('empty TreeMultiMap → rangeSearch returns empty results', () => {
+    const tmm = buildIndex([]);
+    // Any finite range should yield empty
+    const flat = tmm.rangeSearch(new Range(0, 100, true, true), n => n.value).flat();
+    expect(flat).toEqual([]);
+
+    const groups = tmm.rangeSearch(new Range(0, 100, true, true), (node: any) => ({
+      key: node.key,
+      bucket: node.value as Product[]
+    }));
+    expect(groups).toEqual([]);
+  });
+
+  it('left-most/right-most key helpers (if API returns node, unwrap .key)', () => {
+    const tmm = buildIndex(sample);
+    expect(leftKey(tmm)).toBe(12.9);
+    expect(rightKey(tmm)).toBe(199);
+  });
+});

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -83,10 +83,6 @@ class MyGraph<
 
   clear(): void {}
 
-  clone(): any {
-    return {};
-  }
-
   protected _addEdge(edge: EO): boolean {
     return edge ? true : true;
   }

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -685,7 +685,7 @@ describe('DirectedGraph iterative Methods', () => {
   });
 
   it('filter should return vertexMap that satisfy the condition', () => {
-    const filtered = graph.filter(vertex => vertex === 'A' || vertex === 'B');
+    const filtered = graph.filterEntries(key => key === 'A' || key === 'B');
     expect(filtered).toEqual([
       ['A', undefined],
       ['B', undefined]

package/test/unit/data-structures/heap/heap.test.ts

@@ -155,18 +155,14 @@ describe('Heap Operation Test', () => {
       }
     );
 
-    const mappedMinHeap = minHeap.map(
-      item => item.key,
-      (a, b) => a - b
-    );
+    const mappedMinHeap = minHeap.map(item => item.key, { comparator: (a, b) => a - b });
     expect(mappedMinHeap.peek()).toBe(0);
     expect(mappedMinHeap.sort()).toEqual([0, 1, 2, 3, 4, 5, 6]);
 
-    const mappedToElementFnMinHeap = minHeap.map<string, { id: string }>(
-      item => item.key.toString(),
-      (a, b) => Number(a) - Number(b),
-      rawElement => rawElement.id
-    );
+    const mappedToElementFnMinHeap = minHeap.map<string, { id: string }>(item => item.key.toString(), {
+      comparator: (a, b) => Number(a) - Number(b),
+      toElementFn: rawElement => rawElement.id
+    });
     expect(mappedToElementFnMinHeap.peek()).toBe('0');
     expect(mappedToElementFnMinHeap.sort()).toEqual(['0', '1', '2', '3', '4', '5', '6']);
 
@@ -234,17 +230,17 @@ describe('Heap Operation Test', () => {
     expect(hp.leaf).toBe(1);
   });
 
-  it('should error', function () {
-    expect(() => {
-      new Heap([{ key: 1 }, { key: 2 }, { key: 3 }]);
-    }).toThrow(
-      "When comparing object types, a custom comparator must be defined in the constructor's options parameter."
-    );
-  });
+  // it('should error', function () {
+  //   expect(() => {
+  //     new Heap([{ key: 1 }, { key: 2 }, { key: 3 }]);
+  //   }).toThrow(
+  //     "When comparing object types, a custom comparator must be defined in the constructor's options parameter."
+  //   );
+  // });
 });
 
 describe('Heap HOF', () => {
-  let hp: Heap;
+  let hp: Heap<{ key: number }, { key: number }>;
 
   beforeEach(() => {
     hp = new Heap([{ key: 1 }, { key: 2 }, { key: 3 }], { comparator: (a, b) => a.key - b.key });
@@ -256,10 +252,7 @@ describe('Heap HOF', () => {
   });
 
   it('should map', () => {
-    const mapped = hp.map(
-      ({ key }) => [key, key],
-      (a, b) => a[0] - b[0]
-    );
+    const mapped = hp.map(({ key }) => [key, key], { comparator: (a, b) => a[0] - b[0] });
     expect([...mapped]).toEqual([
       [1, 1],
       [2, 2],

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -71,10 +71,7 @@ describe('MaxHeap', () => {
       }
     );
 
-    const mappedMaxHeap = maxHeap.map(
-      item => item.key,
-      (a, b) => b - a
-    );
+    const mappedMaxHeap = maxHeap.map(item => item.key, { comparator: (a, b) => b - a });
     expect(mappedMaxHeap.peek()).toBe(6);
     expect(mappedMaxHeap.sort()).toEqual([6, 5, 4, 3, 2, 1, 0]);
 
@@ -83,11 +80,10 @@ describe('MaxHeap', () => {
       {
         id: string;
       }
-    >(
-      item => item.key.toString(),
-      (a, b) => Number(b) - Number(a),
-      rawElement => rawElement.id
-    );
+    >(item => item.key.toString(), {
+      comparator: (a, b) => Number(b) - Number(a),
+      toElementFn: rawElement => rawElement.id
+    });
     expect(mappedToElementFnMaxHeap.peek()).toBe('6');
     expect(mappedToElementFnMaxHeap.sort()).toEqual(['6', '5', '4', '3', '2', '1', '0']);
 

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -106,10 +106,7 @@ describe('Heap iterative methods', () => {
   });
 
   it('map method correctly maps elements', () => {
-    const result = heap.map(
-      x => x / 10,
-      (a: number, b: number) => a - b
-    );
+    const result = heap.map(x => x / 10, { comparator: (a: number, b: number) => a - b });
     expect([...result]).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
   });
 

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -783,6 +783,16 @@ describe('classic use', () => {
         this.map = new Map<K, DoublyLinkedListNode<CacheEntry<K, V>>>();
       }
 
+      // Get the current cache length
+      get length(): number {
+        return this.list.length;
+      }
+
+      // Check if it is empty
+      get isEmpty(): boolean {
+        return this.list.isEmpty();
+      }
+
       // Get cached value
       get(key: K): V | undefined {
         const node = this.map.get(key);
@@ -828,12 +838,6 @@ describe('classic use', () => {
         }
       }
 
-      // Move the node to the head of the linked list
-      private moveToFront(node: DoublyLinkedListNode<CacheEntry<K, V>>): void {
-        this.list.delete(node);
-        this.list.unshift(node.value);
-      }
-
       // Delete specific key
       delete(key: K): boolean {
         const node = this.map.get(key);
@@ -853,14 +857,10 @@ describe('classic use', () => {
         this.map.clear();
       }
 
-      // Get the current cache length
-      get length(): number {
-        return this.list.length;
-      }
-
-      // Check if it is empty
-      get isEmpty(): boolean {
-        return this.list.isEmpty();
+      // Move the node to the head of the linked list
+      private moveToFront(node: DoublyLinkedListNode<CacheEntry<K, V>>): void {
+        this.list.delete(node);
+        this.list.unshift(node.value);
       }
     }
 

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -618,11 +618,6 @@ describe('SinglyLinkedList', () => {
     list.push(3);
     expect(list.map(value => value * 2).toArray()).toEqual([2, 4, 6]);
   });
-
-  it('should reduce the list', () => {
-    const list1 = SinglyLinkedList.fromArray([1, 2, 3]);
-    expect(list1.reduce((acc, value) => acc + value, 0)).toEqual(6);
-  });
 });
 
 describe('iterable methods', () => {
@@ -651,9 +646,7 @@ describe('iterable methods', () => {
 });
 
 describe('classic uses', () => {
-
   it('@example implementation of a basic text editor', () => {
-
     class TextEditor {
       private content: SinglyLinkedList<string>;
       private cursorIndex: number;

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -139,21 +139,18 @@ describe('MaxPriorityQueue Operation Test', () => {
     expect(filtered instanceof MaxPriorityQueue).toBe(true);
     expect([...filtered]).toEqual([7, 1, 5]);
 
-    const mapped = filtered.map(
-      item => ({ key: item }),
-      (a, b) => b.key - a.key
-    );
+    const mapped = filtered.map(item => ({ key: item }), { comparator: (a, b) => b.key - a.key });
     expect(mapped instanceof MaxPriorityQueue).toBe(true);
     expect([...mapped]).toEqual([{ key: 7 }, { key: 1 }, { key: 5 }]);
   });
 
-  it('should MaxPriorityQueue throw an error while initialed with object data', function () {
-    expect(() => {
-      new MaxPriorityQueue<{ key: number }>([{ key: 7 }, { key: 1 }, { key: 7 }]);
-    }).toThrow(
-      "When comparing object types, a custom comparator must be defined in the constructor's options parameter."
-    );
-  });
+  // it('should MaxPriorityQueue throw an error while initialed with object data', function () {
+  //   expect(() => {
+  //     new MaxPriorityQueue<{ key: number }>([{ key: 7 }, { key: 1 }, { key: 7 }]);
+  //   }).toThrow(
+  //     "When comparing object types, a custom comparator must be defined in the constructor's options parameter."
+  //   );
+  // });
 
   it('should MaxPriorityQueue comparator return 0 when equal values are added', function () {
     const duplicated = new MaxPriorityQueue<number>([7, 1, 7, 7]);

package/test/unit/data-structures/priority-queue/min-priority-queue.test.ts

@@ -70,10 +70,7 @@ describe('MinPriorityQueue Operation Test', () => {
     expect(filtered instanceof MinPriorityQueue).toBe(true);
     expect([...filtered]).toEqual([1, 5, 7]);
 
-    const mapped = filtered.map(
-      item => ({ key: item }),
-      (a, b) => a.key - b.key
-    );
+    const mapped = filtered.map(item => ({ key: item }), { comparator: (a, b) => a.key - b.key });
     expect(mapped instanceof MinPriorityQueue).toBe(true);
     expect([...mapped]).toEqual([{ key: 1 }, { key: 5 }, { key: 7 }]);
     expect(mapped.toVisual()).toEqual([{ key: 1 }, { key: 5 }, { key: 7 }]);

package/test/unit/data-structures/priority-queue/priority-queue.test.ts

@@ -62,10 +62,7 @@ describe('PriorityQueue Operation Test', () => {
     expect(filtered instanceof PriorityQueue).toBe(true);
     expect([...filtered]).toEqual([1, 3, 5, 7]);
 
-    const mapped = filtered.map(
-      item => ({ key: item }),
-      (a, b) => a.key - b.key
-    );
+    const mapped = filtered.map(item => ({ key: item }), { comparator: (a, b) => a.key - b.key });
     expect(mapped instanceof PriorityQueue).toBe(true);
     expect([...mapped]).toEqual([{ key: 1 }, { key: 3 }, { key: 5 }, { key: 7 }]);
   });

package/test/unit/data-structures/queue/queue.test.ts

@@ -153,10 +153,9 @@ describe('Queue', () => {
     expect(mappedQueue.at(0)).toBe(1);
     expect([...mappedQueue]).toEqual([1, 6, 5, 3, 2, 4, 0]);
 
-    const mappedToElementFnQueue = queue.map<string, { id: string }>(
-      item => item.key.toString(),
-      rawElement => rawElement.id
-    );
+    const mappedToElementFnQueue = queue.map<string, { id: string }>(item => item.key.toString(), {
+      toElementFn: rawElement => rawElement.id
+    });
     expect(mappedToElementFnQueue.at(0)).toBe('1');
     expect([...mappedToElementFnQueue]).toEqual(['1', '6', '5', '3', '2', '4', '0']);
 
@@ -603,7 +602,7 @@ describe('classic uses', () => {
     let maxSum = 0;
     let currentSum = 0;
 
-    nums.forEach((num) => {
+    nums.forEach(num => {
       queue.push(num);
       currentSum += num;
 

package/test/unit/utils/utils.test.ts

@@ -172,4 +172,3 @@ describe('isComparable', () => {
     });
   });
 });
-