data-structure-typed 1.51.7 → 1.51.8

package/src/types/data-structures/binary-tree/tree-multi-map.ts

@@ -1,8 +1,9 @@
 import { TreeMultiMap, TreeMultiMapNode } from '../../../data-structures';
 import type { RBTreeOptions } from './rb-tree';
+import { Comparable } from "../../utils";
 
-export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type TreeMultiMapNodeNested<K extends Comparable, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type TreeMultiMapNested<K, V, N extends TreeMultiMapNode<K, V, N>> = TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type TreeMultiMapNested<K extends Comparable, V, N extends TreeMultiMapNode<K, V, N>> = TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type TreeMultiMapOptions<K> = RBTreeOptions<K> & {}

package/src/types/utils/utils.ts

@@ -5,4 +5,17 @@ export type TrlAsyncFn = (...args: any[]) => any;
 
 export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 
-export type Any = string | number | boolean | object | null | undefined | symbol;
+export type Any = string | number | bigint | boolean | symbol | undefined | object;
+
+export type Comparable =
+  | number
+  | string
+  | bigint
+  | boolean
+  | ({ [key in string]: any } & {
+  valueOf(): Comparable;
+})
+  | ({ [key in string]: any } & {
+  toString(): Comparable;
+})
+  | (() => Comparable);

package/src/utils/utils.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from '../types';
+import type { Comparable, Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from '../types';
 
 export const uuidV4 = function () {
   return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
@@ -105,3 +105,22 @@ export const roundFixed = (num: number, digit: number = 10) => {
   const multiplier = Math.pow(10, digit);
   return Math.round(num * multiplier) / multiplier;
 };
+
+export function isComparable(key: any): key is Comparable {
+  const keyType = typeof key;
+  if (keyType === 'number') return isNaN(key);
+  if (keyType === 'string') return true;
+  if (keyType === 'bigint') return true;
+  if (keyType === 'boolean') return true;
+  if (keyType === 'symbol') return false;
+  if (keyType === 'undefined') return false;
+  if (keyType === 'function') return isComparable(key());
+  if (keyType === 'object') {
+    if (key === null) return true;
+    if (typeof key.valueOf === 'function') return isComparable(key.valueOf());
+    if (typeof key.toString === 'function') return isComparable(key.toString());
+    return false;
+  }
+
+  return false;
+}

package/test/integration/all-in-one.test.ts

@@ -3,7 +3,7 @@ import { AVLTree } from 'data-structure-typed';
 describe('AVL Tree Test from data-structure-typed', () => {
   it('should perform various operations on a AVL Tree from data-structure-typed', () => {
     const keys = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree();
+    const tree = new AVLTree<number>();
 
     for (const i of keys) tree.add([i, i]);
 
@@ -27,7 +27,7 @@ describe('AVL Tree Test from data-structure-typed', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.

package/test/integration/index.html

@@ -371,6 +371,76 @@
   } catch (e) {
     console.error(e);
   }
+
+  function heapTest() {
+    const heap = new dataStructureTyped.Heap([], { comparator: (a, b) => b - a });
+
+    heap.add(10);
+    heap.add(5);
+    heap.add(15);
+
+    const max = heap.poll();
+    console.log(max);     // 15
+
+    const max2 = heap.peek();
+    console.log(max2);    // 15
+
+    let isEmpty = heap.isEmpty();
+    console.log(isEmpty); // false
+
+    heap.clear();
+    isEmpty = heap.isEmpty();
+    console.log(isEmpty); // true
+
+    const minNumHeap = new dataStructureTyped.MinHeap([1, 6, 2, 0, 5]);
+    minNumHeap.add(9);
+    minNumHeap.has(1)        //  true
+    minNumHeap.has(2)        //  true
+    minNumHeap.poll()        //  0
+    minNumHeap.poll()        //  1
+    minNumHeap.peek()        //  2
+    minNumHeap.has(1);       // false
+    minNumHeap.has(2);       // true
+
+    const arrFromHeap = minNumHeap.toArray();
+    arrFromHeap.length       //  4
+    arrFromHeap[0]           //  2
+    arrFromHeap[1]           //  5
+    arrFromHeap[2]           //  9
+    arrFromHeap[3]           //  6
+    minNumHeap.sort()        //  [2, 5, 6, 9]
+
+    const maxHeap = new dataStructureTyped.MaxHeap([], { comparator: (a, b) => b.keyA - a.keyA });
+    const obj1 = { keyA: 'a1' }, obj6 = { keyA: 'a6' }, obj5 = { keyA: 'a5' }, obj2 = { keyA: 'a2' },
+      obj0 = { keyA: 'a0' }, obj9 = { keyA: 'a9' };
+
+    maxHeap.add(obj1);
+    maxHeap.has(obj1)                       // true
+    maxHeap.has(obj9)                       // false
+    maxHeap.add(obj6);
+    maxHeap.has(obj6)                       // true
+    maxHeap.add(obj5);
+    maxHeap.add(obj2);
+    maxHeap.add(obj0);
+    maxHeap.add(obj9);
+    maxHeap.has(obj9)                       // true
+
+    const peek9 = maxHeap.peek();
+    console.log(peek9.keyA)             // 'a9'
+
+    const heapToArr = maxHeap.toArray();
+    console.log(heapToArr.map(ele => ele?.keyA));  // ['a9', 'a2', 'a6', 'a1', 'a0', 'a5']
+
+    const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
+    let i = 0;
+    while (maxHeap.size > 0) {
+      const polled = maxHeap.poll();
+      console.log(polled.keyA)           // values[i]
+      i++;
+    }
+  }
+
+
 </script>
 
 </body>

package/test/performance/reportor.ts

@@ -2,13 +2,12 @@ import * as Benchmark from 'benchmark';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as fastGlob from 'fast-glob';
-import { Color, numberFix, render } from '../utils';
+import { ConsoleColor, numberFix, render } from '../utils';
 import { PerformanceTest } from './types';
-import * as console from 'console';
 
 const args = process.argv.slice(2);
 
-const { GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW } = Color;
+const { GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW } = ConsoleColor;
 
 const getRelativePath = (file: string) => {
   return path.relative(__dirname, file);

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

@@ -28,7 +28,7 @@ describe('AVLTreeMultiMap count', () => {
       [3, 3]
     ]);
     tm.add([2, 2], undefined, 10);
-    tm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 1);
+    tm.lesserOrGreaterTraverse(node => (node.count += 2), 1, 1);
     tm.delete(2);
     expect(tm.count).toBe(12);
     expect(tm.getComputedCount()).toBe(16);
@@ -37,7 +37,7 @@ describe('AVLTreeMultiMap count', () => {
 
 describe('AVLTreeMultiMap operations test1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap();
+    const treeMultimap = new AVLTreeMultiMap<number>();
 
     expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
@@ -94,7 +94,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof AVLTreeMultiMapNode);
@@ -105,7 +105,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     const node11 = treeMultimap.getNode(11);
     expect(node11 instanceof AVLTreeMultiMapNode);
     if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
+      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -348,7 +348,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof AVLTreeMultiMapNode);
@@ -359,7 +359,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     const node11 = treeMultimap.getNode(11);
     expect(node11 instanceof AVLTreeMultiMapNode);
     if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
+      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -564,7 +564,7 @@ describe('AVLTreeMultiMap Performance test', function () {
     }
     isDebug && console.log('---add', performance.now() - start);
     const startL = performance.now();
-    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), 'LT', inputSize / 2);
+    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), -1, inputSize / 2);
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 

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

@@ -28,7 +28,7 @@ describe('AVL Tree Test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
@@ -136,7 +136,7 @@ describe('AVL Tree Test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.

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

@@ -58,7 +58,7 @@ describe('BST operations test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -261,7 +261,7 @@ describe('BST operations test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -448,7 +448,7 @@ describe('BST operations test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -649,7 +649,7 @@ describe('BST operations test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -869,7 +869,7 @@ describe('BST isBST', function () {
   });
 
   test('isBST when variant is Max', () => {
-    const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], { variant: 'INVERSE' });
+    const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], { comparator: (a, b) => b - a });
     bst.addMany([1, 2, 3, 9, 8, 5, 6, 7, 4]);
     expect(bst.isBST()).toBe(true);
   });
@@ -902,7 +902,7 @@ describe('BST Performance test', function () {
       node => {
         node.key - 1;
       },
-      'LT',
+      -1,
       inputSize / 2
     );
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);

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

@@ -2,7 +2,7 @@ import { AVLTree, BST, RedBlackTree, TreeMultiMap } from '../../../../src';
 
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
-    const bst = new BST();
+    const bst = new BST<number>();
     bst.add(11);
     bst.add(3);
     bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
@@ -64,16 +64,19 @@ describe('Overall BinaryTree Test', () => {
   it('Should clone a BST works fine', () => {
     const bst = new BST<number>([3, 6, 7, 1, 9], {
       iterationType: 'RECURSIVE',
-      variant: 'INVERSE',
-      extractor: key => key
+      comparator: (a, b) => {
+        if (a > b) return -1;
+        if (a < b) return 1;
+        return 0;
+      }
     });
     expect(bst.size).toBe(5);
     expect(bst.root?.key).toBe(6);
-    expect(bst.root?.left?.key).toBe(7);
-    expect(bst.root?.left?.left?.key).toBe(9);
-    expect(bst.root?.right?.key).toBe(1);
-    expect(bst.root?.right?.left?.key).toBe(3);
-    expect(bst.getNodeByKey(7)?.left?.key).toBe(9);
+    expect(bst.root?.left?.key).toBe(9);
+    expect(bst.root?.left?.right?.key).toBe(7);
+    expect(bst.root?.right?.key).toBe(3);
+    expect(bst.root?.right?.right?.key).toBe(1);
+    expect(bst.getNodeByKey(9)?.right?.key).toBe(7);
     expect(bst.getHeight()).toBe(2);
     expect(bst.has(9)).toBe(true);
     expect(bst.has(7)).toBe(true);
@@ -82,31 +85,34 @@ describe('Overall BinaryTree Test', () => {
     expect(bst.size).toBe(4);
     expect(bst.root?.key).toBe(6);
     expect(bst.root?.left?.key).toBe(9);
-    expect(bst.root?.right?.key).toBe(1);
-    expect(bst.root?.right?.left?.key).toBe(3);
+    expect(bst.root?.right?.key).toBe(3);
+    expect(bst.root?.right?.right?.key).toBe(1);
     expect(bst.getNodeByKey(6)?.left?.key).toBe(9);
     expect(bst.getHeight()).toBe(2);
     expect(bst.has(9)).toBe(true);
     expect(bst.has(7)).toBe(false);
-    expect(bst.bfs()).toEqual([6, 9, 1, 3]);
+    expect(bst.bfs()).toEqual([6, 9, 3, 1]);
     const clonedBST = bst.clone();
     expect(clonedBST.size).toBe(4);
     expect(clonedBST.root?.key).toBe(6);
     expect(clonedBST.root?.left?.key).toBe(9);
-    expect(clonedBST.root?.right?.key).toBe(1);
-    expect(clonedBST.root?.right?.left?.key).toBe(3);
+    expect(clonedBST.root?.right?.key).toBe(3);
+    expect(clonedBST.root?.right?.right?.key).toBe(1);
     expect(clonedBST.getNodeByKey(6)?.left?.key).toBe(9);
     expect(clonedBST.getHeight()).toBe(2);
     expect(clonedBST.has(9)).toBe(true);
     expect(clonedBST.has(7)).toBe(false);
-    expect(clonedBST.bfs()).toEqual([6, 9, 1, 3]);
+    expect(clonedBST.bfs()).toEqual([6, 9, 3, 1]);
   });
 
   it('Should clone a AVLTree works fine', () => {
     const avl = new AVLTree<number>([3, 6, 7, 1, 9], {
       iterationType: 'RECURSIVE',
-      variant: 'INVERSE',
-      extractor: key => key
+      comparator: (a, b) => {
+        if (a > b) return -1;
+        if (a < b) return 1;
+        return 0;
+      }
     });
     expect(avl.size).toBe(5);
     avl.add(2);
@@ -148,8 +154,7 @@ describe('Overall BinaryTree Test', () => {
 
   it('Should clone a TreeMultiMap works fine', () => {
     const tmm = new TreeMultiMap<number>([3, 6, 7, 1, 9], {
-      iterationType: 'RECURSIVE',
-      extractor: key => key
+      iterationType: 'RECURSIVE'
     });
     expect(tmm.size).toBe(5);
     tmm.add(2);
@@ -197,8 +202,7 @@ describe('Overall BinaryTree Test', () => {
 
   it('Should clone a RedBlackTree works fine', () => {
     const rbTree = new RedBlackTree<number>([3, 6, 7, 1, 9], {
-      iterationType: 'RECURSIVE',
-      extractor: key => key
+      iterationType: 'RECURSIVE'
     });
     expect(rbTree.size).toBe(5);
     rbTree.add(2);

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

@@ -32,7 +32,7 @@ describe('TreeMultiMap count', () => {
       [2, 2],
       [3, 3]
     ]);
-    tmm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 1);
+    tmm.lesserOrGreaterTraverse(node => (node.count += 2), 1, 1);
     expect(tmm.getComputedCount()).toBe(7);
     expect(tmm.count).toBe(3);
   });
@@ -93,7 +93,7 @@ describe('TreeMultiMap operations test1', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const tmm = new TreeMultiMap();
+    const tmm = new TreeMultiMap<number, number>();
 
     expect(tmm instanceof TreeMultiMap);
 
@@ -152,7 +152,7 @@ describe('TreeMultiMap operations test1', () => {
     node15 && tmm.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
-    tmm.lesserOrGreaterTraverse((node: TreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
+    tmm.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof TreeMultiMapNode);
@@ -163,7 +163,7 @@ describe('TreeMultiMap operations test1', () => {
     const node11 = tmm.getNode(11);
     expect(node11 instanceof TreeMultiMapNode);
     if (node11 instanceof TreeMultiMapNode) {
-      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
+      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -414,7 +414,7 @@ describe('TreeMultiMap operations test recursively1', () => {
         lesserSum += node.key;
         return node.key;
       },
-      'LT',
+      -1,
       10
     );
     expect(lesserSum).toBe(45);
@@ -427,7 +427,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     const node11 = tmm.getNode(11);
     expect(node11 instanceof TreeMultiMapNode);
     if (node11 instanceof TreeMultiMapNode) {
-      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
+      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
       expect(allGreaterNodesAdded);
     }
 

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

@@ -0,0 +1,5 @@
+describe('isNaN', () => {
+  it('should isNaN', function () {
+    expect(isNaN('string' as unknown as number)).toBe(true);
+  });
+});

package/test/utils/console.ts

@@ -1,4 +1,4 @@
-export const Color = {
+export const ConsoleColor = {
   END: '\x1b[0m',
   BOLD: '\x1b[1m',
   DIM: '\x1b[2m',