data-structure-typed 1.39.1 → 1.39.2

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -87,17 +87,13 @@ export class SinglyLinkedList<E = any> {
     return singlyLinkedList;
   }
 
-  getLength(): number {
-    return this._length;
-  }
-
   /**
-   * The `push` function adds a new node with the given data to the end of a singly linked list.
-   * @param {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+   * The `push` function adds a new node with the given val to the end of a singly linked list.
+   * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
    * any type (E) as specified in the generic type declaration of the class or function.
    */
-  push(data: E): void {
-    const newNode = new SinglyLinkedListNode(data);
+  push(val: E): void {
+    const newNode = new SinglyLinkedListNode(val);
     if (!this.head) {
       this.head = newNode;
       this.tail = newNode;
@@ -108,6 +104,15 @@ export class SinglyLinkedList<E = any> {
     this._length++;
   }
 
+  /**
+   * The `push` function adds a new node with the given val to the end of a singly linked list.
+   * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
+   * any type (E) as specified in the generic type declaration of the class or function.
+   */
+  addLast(val: E): void {
+    this.push(val);
+  }
+
   /**
    * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
    * pointers accordingly.
@@ -135,6 +140,16 @@ export class SinglyLinkedList<E = any> {
     return val;
   }
 
+  /**
+   * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
+   * pointers accordingly.
+   * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
+   * the linked list is empty, it returns `null`.
+   */
+  popLast(): E | undefined {
+    return this.pop();
+  }
+
   /**
    * The `shift()` function removes and returns the value of the first node in a linked list.
    * @returns The value of the node that is being removed from the beginning of the linked list.
@@ -147,6 +162,14 @@ export class SinglyLinkedList<E = any> {
     return removedNode.val;
   }
 
+  /**
+   * The `popFirst()` function removes and returns the value of the first node in a linked list.
+   * @returns The value of the node that is being removed from the beginning of the linked list.
+   */
+  popFirst(): E | undefined {
+    return this.shift();
+  }
+
   /**
    * The unshift function adds a new node with the given value to the beginning of a singly linked list.
    * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
@@ -164,6 +187,15 @@ export class SinglyLinkedList<E = any> {
     this._length++;
   }
 
+  /**
+   * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
+   * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+   * linked list.
+   */
+  addFirst(val: E): void {
+    this.unshift(val);
+  }
+
   /**
    * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
    * @param {number} index - The index parameter is a number that represents the position of the element we want to
@@ -382,7 +414,7 @@ export class SinglyLinkedList<E = any> {
    * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
    * the specified value is found, the function returns `null`.
    */
-  findNode(value: E): SinglyLinkedListNode<E> | null {
+  getNode(value: E): SinglyLinkedListNode<E> | null {
     let current = this.head;
 
     while (current) {
@@ -432,9 +464,6 @@ export class SinglyLinkedList<E = any> {
     return false;
   }
 
-  insertAfter(existingValueOrNode: E, newValue: E): boolean;
-  insertAfter(existingValueOrNode: SinglyLinkedListNode<E>, newValue: E): boolean;
-
   /**
    * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
    * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
@@ -449,7 +478,7 @@ export class SinglyLinkedList<E = any> {
     if (existingValueOrNode instanceof SinglyLinkedListNode) {
       existingNode = existingValueOrNode;
     } else {
-      existingNode = this.findNode(existingValueOrNode);
+      existingNode = this.getNode(existingValueOrNode);
     }
 
     if (existingNode) {
@@ -485,7 +514,83 @@ export class SinglyLinkedList<E = any> {
     return count;
   }
 
-  *[Symbol.iterator]() {
+  /**
+   * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+   * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
+   * represents the value of the current node in the linked list, and the index argument represents the index of the
+   * current node in the linked list.
+   */
+  forEach(callback: (val: E, index: number) => void): void {
+    let current = this.head;
+    let index = 0;
+    while (current) {
+      callback(current.val, index);
+      current = current.next;
+      index++;
+    }
+  }
+
+  /**
+   * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
+   * SinglyLinkedList with the transformed values.
+   * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+   * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
+   * SinglyLinkedList).
+   * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+   */
+  map<U>(callback: (val: E) => U): SinglyLinkedList<U> {
+    const mappedList = new SinglyLinkedList<U>();
+    let current = this.head;
+    while (current) {
+      mappedList.push(callback(current.val));
+      current = current.next;
+    }
+    return mappedList;
+  }
+
+  /**
+   * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
+   * elements that satisfy the given callback function.
+   * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
+   * It is used to determine whether a value should be included in the filtered list or not.
+   * @returns The filtered list, which is an instance of the SinglyLinkedList class.
+   */
+  filter(callback: (val: E) => boolean): SinglyLinkedList<E> {
+    const filteredList = new SinglyLinkedList<E>();
+    let current = this.head;
+    while (current) {
+      if (callback(current.val)) {
+        filteredList.push(current.val);
+      }
+      current = current.next;
+    }
+    return filteredList;
+  }
+
+  /**
+   * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+   * single value.
+   * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
+   * used to perform a specific operation on each element of the linked list.
+   * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+   * point for the reduction operation.
+   * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+   * elements in the linked list.
+   */
+  reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U {
+    let accumulator = initialValue;
+    let current = this.head;
+    while (current) {
+      accumulator = callback(accumulator, current.val);
+      current = current.next;
+    }
+    return accumulator;
+  }
+
+  /**
+   * The function returns an iterator that iterates over the values of a linked list.
+   */
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

package/src/data-structures/matrix/matrix.ts

@@ -14,7 +14,7 @@ export class MatrixNTI2D<V = any> {
    * given initial value or 0 if not provided.
    * @param options - An object containing the following properties:
    */
-  constructor(options: {row: number; col: number; initialVal?: V}) {
+  constructor(options: { row: number; col: number; initialVal?: V }) {
     const {row, col, initialVal} = options;
     this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
   }

package/src/data-structures/matrix/vector2d.ts

@@ -10,7 +10,8 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {}
+  ) {
+  }
 
   /**
    * The function checks if the x and y values of a point are both zero.

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/priority-queue/priority-queue.ts

@@ -10,7 +10,7 @@ import {Heap} from '../heap';
 import {Comparator} from '../../types';
 
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
     super(options);
   }
 }

package/src/data-structures/queue/deque.ts

@@ -9,7 +9,8 @@ import {DoublyLinkedList} from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {}
+export class Deque<E = any> extends DoublyLinkedList<E> {
+}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -19,9 +20,9 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  private _nodes: {[key: number]: E} = {};
+  private _nodes: { [key: number]: E } = {};
 
-  get nodes(): {[p: number]: E} {
+  get nodes(): { [p: number]: E } {
     return this._nodes;
   }
 
@@ -95,12 +96,12 @@ export class ObjectDeque<E = number> {
   }
 
   /**
-   * The function `pollFirst()` removes and returns the first element in a data structure.
+   * The function `popFirst()` removes and returns the first element in a data structure.
    * @returns The value of the first element in the data structure.
    */
-  pollFirst() {
+  popFirst() {
     if (!this._size) return;
-    const value = this.peekFirst();
+    const value = this.getFirst();
     delete this._nodes[this._first];
     this._first++;
     this._size--;
@@ -108,20 +109,20 @@ export class ObjectDeque<E = number> {
   }
 
   /**
-   * The `peekFirst` function returns the first element in an array-like data structure if it exists.
+   * The `getFirst` function returns the first element in an array-like data structure if it exists.
    * @returns The element at the first position of the `_nodes` array.
    */
-  peekFirst() {
+  getFirst() {
     if (this._size) return this._nodes[this._first];
   }
 
   /**
-   * The `pollLast()` function removes and returns the last element in a data structure.
+   * The `popLast()` function removes and returns the last element in a data structure.
    * @returns The value that was removed from the data structure.
    */
-  pollLast() {
+  popLast() {
     if (!this._size) return;
-    const value = this.peekLast();
+    const value = this.getLast();
     delete this._nodes[this._last];
     this._last--;
     this._size--;
@@ -130,10 +131,10 @@ export class ObjectDeque<E = number> {
   }
 
   /**
-   * The `peekLast()` function returns the last element in an array-like data structure.
+   * The `getLast()` function returns the last element in an array-like data structure.
    * @returns The last element in the array "_nodes" is being returned.
    */
-  peekLast() {
+  getLast() {
     if (this._size) return this._nodes[this._last];
   }
 
@@ -156,7 +157,7 @@ export class ObjectDeque<E = number> {
     return this._size <= 0;
   }
 
-  protected _seNodes(value: {[p: number]: E}) {
+  protected _seNodes(value: { [p: number]: E }) {
     this._nodes = value;
   }
 
@@ -188,19 +189,19 @@ export class ArrayDeque<E> {
   }
 
   /**
-   * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
-   * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+   * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
+   * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
    */
-  pollLast(): E | null {
+  popLast(): E | null {
     return this._nodes.pop() ?? null;
   }
 
   /**
-   * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
-   * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
+   * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+   * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
    * empty.
    */
-  pollFirst(): E | null {
+  popFirst(): E | null {
     return this._nodes.shift() ?? null;
   }
 
@@ -219,19 +220,19 @@ export class ArrayDeque<E> {
   }
 
   /**
-   * The `peekFirst` function returns the first element of an array or null if the array is empty.
-   * @returns The function `peekFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
+   * The `getFirst` function returns the first element of an array or null if the array is empty.
+   * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
    * empty, it will return `null`.
    */
-  peekFirst(): E | null {
+  getFirst(): E | null {
     return this._nodes[0] ?? null;
   }
 
   /**
-   * The `peekLast` function returns the last element of an array or null if the array is empty.
-   * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+   * The `getLast` function returns the last element of an array or null if the array is empty.
+   * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
    */
-  peekLast(): E | null {
+  getLast(): E | null {
     return this._nodes[this._nodes.length - 1] ?? null;
   }
 

package/src/data-structures/queue/queue.ts

@@ -123,11 +123,11 @@ export class Queue<E = any> {
   }
 
   /**
-   * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
-   * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+   * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+   * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
    * array is empty, it returns `null`.
    */
-  peekLast(): E | undefined {
+  getLast(): E | undefined {
     return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
   }
 
@@ -183,7 +183,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }

package/src/types/data-structures/matrix/navigator.ts

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = {[key in Direction]: Direction};
+export type Turning = { [key in Direction]: Direction };
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 

package/src/types/utils/validate-type.ts

@@ -1,6 +1,6 @@
-export type KeyValueObject = {[key: string]: any};
+export type KeyValueObject = { [key: string]: any };
 
-export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
+export type KeyValueObjectWithKey = { [key: string]: any; key: string | number | symbol };
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
 

package/test/integration/bst.test.ts

@@ -183,7 +183,7 @@ describe('Individual package BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});

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

@@ -219,7 +219,7 @@ describe('AVL Tree Test recursively', () => {
 });
 
 describe('AVLTree APIs test', () => {
-  const avl = new AVLTree<{id: number; text: string}>();
+  const avl = new AVLTree<{ id: number; text: string }>();
   beforeEach(() => {
     avl.clear();
   });

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

@@ -125,11 +125,19 @@ describe('BinaryTree', () => {
   });
 
   it('should traverse in-order', () => {
+    tree.add(null);
+    tree.delete(1);
+    expect(tree.getHeight()).toBe(-1);
     tree.add(4);
     tree.add(2);
+    expect(tree.getHeight()).toBe(1);
+    tree.iterationType = IterationType.RECURSIVE;
+    expect(tree.getHeight()).toBe(1);
+    tree.iterationType = IterationType.ITERATIVE;
+
     tree.add(6);
     tree.add(1);
-    tree.add(3);
+    tree.add(new BinaryTreeNode(3));
     tree.add(5);
     tree.add(7);
 
@@ -160,6 +168,7 @@ describe('BinaryTree', () => {
     ]);
 
     expect(tree.isSubtreeBST(tree.get(4), IterationType.RECURSIVE)).toBe(true);
+    expect(tree.isSubtreeBST(tree.get(4), IterationType.ITERATIVE)).toBe(true);
   });
 
   it('should subTreeTraverse', () => {
@@ -197,6 +206,7 @@ describe('BinaryTree Morris Traversal', () => {
 
     expect(result).toEqual(expected);
     expect(tree.dfs(node => node.key, 'in')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'in', tree.root, IterationType.RECURSIVE)).toEqual(expected);
   });
 
   it('should perform pre-order Morris traversal correctly as dfs traversal', () => {
@@ -231,7 +241,7 @@ describe('BinaryTree Morris Traversal', () => {
 });
 
 describe('BinaryTree APIs test', () => {
-  const avl = new AVLTree<{id: number; text: string}>();
+  const avl = new AVLTree<{ id: number; text: string }>();
   beforeEach(() => {
     avl.clear();
   });
@@ -255,8 +265,10 @@ describe('BinaryTree traversals', () => {
   const arr = [35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55];
   tree.refill(arr);
   expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
+  expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
   expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
   expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
+  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
   expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([
     35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
   ]);
@@ -281,7 +293,7 @@ describe('BinaryTree', () => {
   let tree: BinaryTree<string>;
 
   beforeEach(() => {
-    tree = new BinaryTree<string>();
+    tree = new BinaryTree<string>({iterationType: IterationType.RECURSIVE});
   });
 
   afterEach(() => {
@@ -441,6 +453,14 @@ describe('BinaryTree', () => {
     tree.add(3, 'B');
     tree.add(7, 'C');
 
+    tree.iterationType = IterationType.ITERATIVE;
+    // @ts-ignore
+    expect([...tree]).toEqual([3, 5, 7]);
+    tree.iterationType = IterationType.RECURSIVE;
+    // @ts-ignore
+    expect([...tree]).toEqual([3, 5, 7]);
+    tree.iterationType = IterationType.ITERATIVE;
+
     const result = tree.morris();
     expect(result).toEqual([3, 5, 7]);
     // Add assertions for the result of Morris traversal

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

@@ -189,7 +189,7 @@ describe('BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
@@ -260,7 +260,7 @@ describe('BST operations test', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -385,7 +385,7 @@ describe('BST operations test', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodes: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
@@ -579,7 +579,7 @@ describe('BST operations test recursively', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
@@ -650,7 +650,7 @@ describe('BST operations test recursively', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -775,7 +775,7 @@ describe('BST operations test recursively', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodes: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);

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

@@ -29,7 +29,7 @@ describe('Overall BinaryTree Test', () => {
     bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
 

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

@@ -207,7 +207,7 @@ describe('TreeMultiset operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>();
+    const objTreeMultiset = new TreeMultiset<{ key: number; keyA: number }>();
     expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
     objTreeMultiset.add(11, {key: 11, keyA: 11});
     objTreeMultiset.add(3, {key: 3, keyA: 3});
@@ -447,7 +447,7 @@ describe('TreeMultiset operations test recursively', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>();
+    const objTreeMultiset = new TreeMultiset<{ key: number; keyA: number }>();
     expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
     objTreeMultiset.add(11, {key: 11, keyA: 11});
     objTreeMultiset.add(3, {key: 3, keyA: 3});

package/test/unit/data-structures/hash/coordinate-map.test.ts

@@ -52,3 +52,23 @@ describe('CoordinateMap', () => {
     expect(retrievedValue).toBe(value);
   });
 });
+
+describe('CoordinateMap', () => {
+  class MyCoordinateMap<V = any> extends CoordinateMap<V> {
+    constructor(joint?: string) {
+      super(joint);
+      this._setJoint(joint += '-')
+    }
+  }
+
+  const cMap = new MyCoordinateMap<number>('*');
+
+  beforeEach(() => {
+    cMap.set([0, 0], 0);
+    cMap.set([0, 1], 1);
+    cMap.set([1, 1], 11);
+  })
+  it('should joint to be *-', () => {
+    expect(cMap.joint).toBe('*-');
+  });
+});