data-structure-typed 2.0.4 → 2.1.0

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');
@@ -1537,6 +1536,86 @@ 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,
+      isReverse: true
+    });
+    bst.add(1);
+    bst.add(2);
+    expect(bst.isReverse).toBe(true);
+    expect(bst['_specifyComparable']).toBeDefined();
+    expect([...bst.keys()]).toEqual([2, 1]);
+  });
+
+  it('should throw if compare object key without specifyComparable', () => {
+    const bst = new BST<any>();
+    expect(() => bst.comparator({ a: 1 }, { a: 2 })).toThrow();
+  });
+});
+
+describe('BST addMany edge cases', () => {
+  it('should addMany with values iterable', () => {
+    const bst = new BST<number, string>();
+    const keys = [1, 2, 3];
+    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']
+    ]);
+  });
+
+  it('should addMany with isBalanceAdd=false', () => {
+    const bst = new BST<number>();
+    const result = bst.addMany([3, 1, 2], undefined, false);
+    expect(result).toEqual([true, true, true]);
+    expect([...bst.keys()]).toEqual([1, 2, 3]);
+  });
+
+  it('should addMany with raw/entry/node', () => {
+    const bst = new BST<number, string>([], { isMapMode: false });
+    const node = new BSTNode(5, 'x');
+    const result = bst.addMany([1, [2, 'b'], node]);
+    expect(result).toEqual([true, true, true]);
+    expect(bst.get(5)).toBe('x');
+  });
+});
+
+describe('BST perfectlyBalance and isAVLBalanced edge cases', () => {
+  it('should perfectlyBalance with <1 node and both iterationType', () => {
+    const bst = new BST<number>();
+    expect(bst.perfectlyBalance('RECURSIVE')).toBe(false);
+    expect(bst.perfectlyBalance('ITERATIVE')).toBe(false);
+    bst.addMany([1, 2, 3]);
+    expect(bst.perfectlyBalance('RECURSIVE')).toBe(true);
+    bst.clear();
+    bst.addMany([1, 2, 3]);
+    expect(bst.perfectlyBalance('ITERATIVE')).toBe(true);
+  });
+
+  it('should isAVLBalanced with both iterationType', () => {
+    const bst = new BST<number>();
+    expect(bst.isAVLBalanced('RECURSIVE')).toBe(true);
+    expect(bst.isAVLBalanced('ITERATIVE')).toBe(true);
+    bst.addMany([1, 2, 3, 4, 5]);
+    expect(typeof bst.isAVLBalanced('RECURSIVE')).toBe('boolean');
+    expect(typeof bst.isAVLBalanced('ITERATIVE')).toBe('boolean');
+  });
+});
+
+describe('BST _keyValueNodeOrEntryToNodeAndValue edge', () => {
+  it('should return [undefined, undefined] for null', () => {
+    const bst = new BST<number>();
+    // @ts-ignore
+    const result = bst['_keyValueNodeOrEntryToNodeAndValue'](null);
+    expect(result).toEqual([undefined, undefined]);
+  });
+});
+
 describe('classic use', () => {
   it('@example Merge 3 sorted datasets', () => {
     const dataset1 = new BST<number, string>([

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,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, IBinaryTree, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
 import { getRandomInt } from '../../../utils';
 
 import { isDebugTest } from '../../../config';
@@ -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']]);

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', () => {
     });
   });
 });
-

package/test/performance/data-structures/binary-tree/avl-tree.test.mjs

@@ -1,71 +0,0 @@
-import { AVLTree } from 'data-structure-typed';
-import Benchmark from 'benchmark';
-
-const magnitude = {
-  THOUSAND: 1000,
-  TEN_THOUSAND: 10000,
-  HUNDRED_THOUSAND: 100000,
-  MILLION: 1000000,
-  TEN_MILLION: 10000000,
-  BILLION: 100000000
-};
-
-function getRandomIntArray(length = 1000, min = -1000, max = 1000, unique = true) {
-  if (unique) {
-    if (max - min + 1 < length) {
-      throw new Error('Range too small for unique values with the specified length');
-    }
-    const allNumbers = Array.from({ length: max - min + 1 }, (_, i) => i + min);
-    for (let i = allNumbers.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [allNumbers[i], allNumbers[j]] = [allNumbers[j], allNumbers[i]];
-    }
-    return allNumbers.slice(0, length);
-  }
-  else {
-    return Array.from({ length }, () => Math.floor(Math.random() * (max - min + 1)) + min);
-  }
-}
-
-const suite = new Benchmark.Suite();
-const avlTree = new AVLTree();
-const { HUNDRED_THOUSAND } = magnitude;
-const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
-suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
-    avlTree.clear();
-    for (let i = 0; i < randomArray.length; i++)
-      avlTree.add(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-    avlTree.clear();
-    for (let i = 0; i < randomArray.length; i++)
-      avlTree.add(i);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
-    for (let i = 0; i < randomArray.length; i++)
-      avlTree.get(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
-    for (let i = 0; i < randomArray.length; i++)
-      avlTree.getNode(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
-    const entries = [...avlTree];
-    return entries.length === HUNDRED_THOUSAND;
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete orderly`, () => {
-    avlTree.clear();
-    for (let i = 0; i < randomArray.length; i++)
-      avlTree.add(i);
-    for (let i = 0; i < randomArray.length; i++)
-      avlTree.delete(i);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
-    avlTree.clear();
-    for (let i = 0; i < randomArray.length; i++)
-      avlTree.add(randomArray[i]);
-    for (let i = 0; i < randomArray.length; i++)
-      avlTree.delete(randomArray[i]);
-  });
-export { suite };