data-structure-typed 1.45.0 → 1.45.1

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

@@ -1,5 +1,5 @@
-import {CP, IterationType, TreeMultimap, TreeMultimapNode} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { CP, IterationType, TreeMultimap, TreeMultimapNode } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 
@@ -209,23 +209,23 @@ describe('TreeMultimap operations test', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add(11, {key: 11, keyA: 11});
-    objTreeMultimap.add(3, {key: 3, keyA: 3});
+    objTreeMultimap.add(11, { key: 11, keyA: 11 });
+    objTreeMultimap.add(3, { key: 3, keyA: 3 });
     const values = [
-      {key: 15, keyA: 15},
-      {key: 1, keyA: 1},
-      {key: 8, keyA: 8},
-      {key: 13, keyA: 13},
-      {key: 16, keyA: 16},
-      {key: 2, keyA: 2},
-      {key: 6, keyA: 6},
-      {key: 9, keyA: 9},
-      {key: 12, keyA: 12},
-      {key: 14, keyA: 14},
-      {key: 4, keyA: 4},
-      {key: 7, keyA: 7},
-      {key: 10, keyA: 10},
-      {key: 5, keyA: 5}
+      { key: 15, keyA: 15 },
+      { key: 1, keyA: 1 },
+      { key: 8, keyA: 8 },
+      { key: 13, keyA: 13 },
+      { key: 16, keyA: 16 },
+      { key: 2, keyA: 2 },
+      { key: 6, keyA: 6 },
+      { key: 9, keyA: 9 },
+      { key: 12, keyA: 12 },
+      { key: 14, keyA: 14 },
+      { key: 4, keyA: 4 },
+      { key: 7, keyA: 7 },
+      { key: 10, keyA: 10 },
+      { key: 5, keyA: 5 }
     ];
 
     objTreeMultimap.addMany(
@@ -245,7 +245,7 @@ describe('TreeMultimap operations test', () => {
 
 describe('TreeMultimap operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const treeMultimap = new TreeMultimap({iterationType: IterationType.RECURSIVE});
+    const treeMultimap = new TreeMultimap({ iterationType: IterationType.RECURSIVE });
 
     expect(treeMultimap instanceof TreeMultimap);
     treeMultimap.add(11, 11);
@@ -449,23 +449,23 @@ describe('TreeMultimap operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add(11, {key: 11, keyA: 11});
-    objTreeMultimap.add(3, {key: 3, keyA: 3});
+    objTreeMultimap.add(11, { key: 11, keyA: 11 });
+    objTreeMultimap.add(3, { key: 3, keyA: 3 });
     const values = [
-      {key: 15, keyA: 15},
-      {key: 1, keyA: 1},
-      {key: 8, keyA: 8},
-      {key: 13, keyA: 13},
-      {key: 16, keyA: 16},
-      {key: 2, keyA: 2},
-      {key: 6, keyA: 6},
-      {key: 9, keyA: 9},
-      {key: 12, keyA: 12},
-      {key: 14, keyA: 14},
-      {key: 4, keyA: 4},
-      {key: 7, keyA: 7},
-      {key: 10, keyA: 10},
-      {key: 5, keyA: 5}
+      { key: 15, keyA: 15 },
+      { key: 1, keyA: 1 },
+      { key: 8, keyA: 8 },
+      { key: 13, keyA: 13 },
+      { key: 16, keyA: 16 },
+      { key: 2, keyA: 2 },
+      { key: 6, keyA: 6 },
+      { key: 9, keyA: 9 },
+      { key: 12, keyA: 12 },
+      { key: 14, keyA: 14 },
+      { key: 4, keyA: 4 },
+      { key: 7, keyA: 7 },
+      { key: 10, keyA: 10 },
+      { key: 5, keyA: 5 }
     ];
 
     objTreeMultimap.addMany(

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

@@ -1,4 +1,4 @@
-import {AbstractEdge, AbstractGraph, AbstractVertex, VertexKey} from '../../../../src';
+import { AbstractEdge, AbstractGraph, AbstractVertex, VertexKey } from '../../../../src';
 
 class MyVertex<V = any> extends AbstractVertex<V> {
   data?: V;
@@ -22,12 +22,12 @@ class MyEdge<E = any> extends AbstractEdge<E> {
   }
 }
 
-class MyGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends MyEdge<E> = MyEdge<E>> extends AbstractGraph<
-  V,
-  E,
-  VO,
-  EO
-> {
+class MyGraph<
+  V = any,
+  E = any,
+  VO extends MyVertex<V> = MyVertex<V>,
+  EO extends MyEdge<E> = MyEdge<E>
+> extends AbstractGraph<V, E, VO, EO> {
   createVertex(key: VertexKey, value?: V): VO {
     return new MyVertex(key, value) as VO;
   }

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

@@ -1,4 +1,4 @@
-import {DirectedEdge, DirectedGraph, DirectedVertex, VertexKey} from '../../../../src';
+import { DirectedEdge, DirectedGraph, DirectedVertex, VertexKey } from '../../../../src';
 
 describe('DirectedGraph Operation Test', () => {
   let graph: DirectedGraph;
@@ -126,12 +126,12 @@ class MyEdge<E = any> extends DirectedEdge<E> {
   }
 }
 
-class MyDirectedGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends MyEdge<E> = MyEdge<E>> extends DirectedGraph<
-  V,
-  E,
-  VO,
-  EO
-> {
+class MyDirectedGraph<
+  V = any,
+  E = any,
+  VO extends MyVertex<V> = MyVertex<V>,
+  EO extends MyEdge<E> = MyEdge<E>
+> extends DirectedGraph<V, E, VO, EO> {
   createVertex(key: VertexKey, value: V): VO {
     return new MyVertex(key, value) as VO;
   }
@@ -319,7 +319,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     const fordResult1 = myGraph.bellmanFord(1);
     expect(fordResult1).toBeTruthy();
     expect(fordResult1.hasNegativeCycle).toBeUndefined();
-    const {distMap, preMap, paths, min, minPath} = fordResult1;
+    const { distMap, preMap, paths, min, minPath } = fordResult1;
     expect(distMap).toBeInstanceOf(Map);
     expect(distMap.size).toBe(9);
     expect(distMap.get(vertex1)).toBe(0);
@@ -343,7 +343,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     const floydResult = myGraph.floydWarshall();
     expect(floydResult).toBeTruthy();
     if (floydResult) {
-      const {costs, predecessor} = floydResult;
+      const { costs, predecessor } = floydResult;
       expect(costs).toBeInstanceOf(Array);
       expect(costs.length).toBe(9);
       expect(costs[0]).toEqual([32, 12, 35, 14, 70, Infinity, 61, Infinity, 19]);
@@ -351,9 +351,29 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(costs[2]).toEqual([3, 15, 38, 17, 35, Infinity, 64, Infinity, 22]);
       expect(costs[3]).toEqual([123, 135, 120, 137, 155, Infinity, 47, Infinity, 126]);
       expect(costs[4]).toEqual([133, 145, 130, 147, 165, Infinity, 57, Infinity, 136]);
-      expect(costs[5]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
+      expect(costs[5]).toEqual([
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity
+      ]);
       expect(costs[6]).toEqual([76, 88, 73, 90, 108, Infinity, 137, Infinity, 79]);
-      expect(costs[7]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
+      expect(costs[7]).toEqual([
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity
+      ]);
       expect(costs[8]).toEqual([173, 185, 170, 187, 205, Infinity, 97, Infinity, 176]);
 
       expect(predecessor).toBeInstanceOf(Array);
@@ -369,7 +389,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
     expect(dijkstraRes12tt).toBeTruthy();
     if (dijkstraRes12tt) {
-      const {distMap, minDist, minPath, paths} = dijkstraRes12tt;
+      const { distMap, minDist, minPath, paths } = dijkstraRes12tt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
@@ -420,7 +440,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
     expect(dijkstraRes1ntt).toBeTruthy();
     if (dijkstraRes1ntt) {
-      const {distMap, minDist, minPath, paths} = dijkstraRes1ntt;
+      const { distMap, minDist, minPath, paths } = dijkstraRes1ntt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
@@ -482,7 +502,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     const dijkstraWithoutHeapRes1ntt = myGraph.dijkstraWithoutHeap(1, null, true, true);
     expect(dijkstraWithoutHeapRes1ntt).toBeTruthy();
     if (dijkstraWithoutHeapRes1ntt) {
-      const {distMap, minDist, minPath, paths} = dijkstraWithoutHeapRes1ntt;
+      const { distMap, minDist, minPath, paths } = dijkstraWithoutHeapRes1ntt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);

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

@@ -1,4 +1,4 @@
-import {MapEdge, MapGraph, MapVertex} from '../../../../src';
+import { MapEdge, MapGraph, MapVertex } from '../../../../src';
 
 describe('MapGraph Operation Test', () => {
   it('dijkstra shortest path', () => {

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

@@ -1,4 +1,4 @@
-import {DirectedGraph, UndirectedGraph} from '../../../../src';
+import { DirectedGraph, UndirectedGraph } from '../../../../src';
 
 describe('Overall Graph Operation Test', () => {
   it('Overall DirectedGraph Operation Test', () => {

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

@@ -1,4 +1,4 @@
-import {UndirectedEdge, UndirectedGraph, UndirectedVertex} from '../../../../src';
+import { UndirectedEdge, UndirectedGraph, UndirectedVertex } from '../../../../src';
 import saltyVertexes from './salty-vertexes.json';
 import saltyEdges from './salty-edges.json';
 

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

@@ -1,4 +1,4 @@
-import {CoordinateMap} from '../../../../src';
+import { CoordinateMap } from '../../../../src';
 
 describe('CoordinateMap', () => {
   it('should set and get values correctly', () => {

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

@@ -1,4 +1,4 @@
-import {CoordinateSet} from '../../../../src';
+import { CoordinateSet } from '../../../../src';
 
 describe('CoordinateSet', () => {
   it('should add and check values correctly', () => {

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

@@ -1,6 +1,5 @@
-import {HashMap} from '../../../../src';
-import {getRandomInt, getRandomIntArray} from "../../../utils";
-
+import { HashMap } from '../../../../src';
+import { getRandomInt, getRandomIntArray } from '../../../utils';
 
 describe('HashMap', () => {
   let hashMap: HashMap<string, number>;
@@ -66,7 +65,6 @@ describe('HashMap', () => {
     // expect(entries).toContainEqual(['three', 3]);
   });
 
-
   it('should resize the table when load factor is exceeded', () => {
     // Set a small initial capacity for testing resizing
     hashMap = new HashMap<string, number>();
@@ -84,7 +82,6 @@ describe('HashMap', () => {
   });
 
   it('should allow using a custom hash function', () => {
-
     hashMap = new HashMap<string, number>();
 
     hashMap.set('one', 1);
@@ -115,14 +112,14 @@ describe('HashMap', () => {
   });
 
   it('should handle object keys correctly', () => {
-    const keyObj = {id: 1};
+    const keyObj = { id: 1 };
     hashMap.set(keyObj, 'objectValue');
     expect(hashMap.get(keyObj)).toBe('objectValue');
   });
 
   it('should handle number keys correctly', () => {
-    hashMap.set(999, {a: '999Value'});
-    expect(hashMap.get(999)).toEqual({a: '999Value'});
+    hashMap.set(999, { a: '999Value' });
+    expect(hashMap.get(999)).toEqual({ a: '999Value' });
   });
 
   it('should update the value for an existing key', () => {
@@ -156,7 +153,10 @@ describe('HashMap', () => {
     for (const value of hashMap) {
       values.push(value);
     }
-    expect(values).toEqual([['key1', 'value1'], ['key2', 'value2']]);
+    expect(values).toEqual([
+      ['key1', 'value1'],
+      ['key2', 'value2']
+    ]);
   });
 
   // test('should delete element at specific index', () => {
@@ -212,7 +212,6 @@ describe('HashMap', () => {
     hashMap.set('key2', 'value2');
     const iterator = hashMap.reverseBegin;
     expect(iterator.next().current).toEqual(['key1', 'value1']);
-
   });
 
   test('should return the last element', () => {
@@ -230,5 +229,4 @@ describe('HashMap', () => {
     hashMap.set('key2', 'value2');
     expect(hashMap.getAt(1)).toEqual(['key2', 'value2']);
   });
-})
-
+});

package/test/unit/data-structures/hash/hash-table.test.ts

@@ -1,4 +1,4 @@
-import {HashTable, HashTableNode} from '../../../../src';
+import { HashTable, HashTableNode } from '../../../../src';
 
 describe('HashNode', () => {
   it('should create a HashNode with key and value', () => {

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

@@ -1,5 +1,5 @@
-import {FibonacciHeap, MaxHeap, MinHeap} from '../../../../src';
-import {logBigOMetricsWrap} from '../../../utils';
+import { FibonacciHeap, MaxHeap, MinHeap } from '../../../../src';
+import { logBigOMetricsWrap } from '../../../utils';
 
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
@@ -22,34 +22,46 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{ a: string; key: number }>({comparator: (a, b) => a.key - b.key});
-    minHeap.add({key: 1, a: 'a1'});
-    minHeap.add({key: 6, a: 'a6'});
-    minHeap.add({key: 2, a: 'a2'});
-    minHeap.add({key: 0, a: 'a0'});
-
-    expect(minHeap.peek()).toEqual({a: 'a0', key: 0});
-    expect(minHeap.toArray().map(item => ({a: item.a}))).toEqual([{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}]);
+    const minHeap = new MinHeap<{ a: string; key: number }>({ comparator: (a, b) => a.key - b.key });
+    minHeap.add({ key: 1, a: 'a1' });
+    minHeap.add({ key: 6, a: 'a6' });
+    minHeap.add({ key: 2, a: 'a2' });
+    minHeap.add({ key: 0, a: 'a0' });
+
+    expect(minHeap.peek()).toEqual({ a: 'a0', key: 0 });
+    expect(minHeap.toArray().map(item => ({ a: item.a }))).toEqual([
+      { a: 'a0' },
+      { a: 'a1' },
+      { a: 'a2' },
+      { a: 'a6' }
+    ]);
     let i = 0;
-    const expectPolled = [{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}];
+    const expectPolled = [{ a: 'a0' }, { a: 'a1' }, { a: 'a2' }, { a: 'a6' }];
     while (minHeap.size > 0) {
-      expect({a: minHeap.poll()?.a}).toEqual(expectPolled[i]);
+      expect({ a: minHeap.poll()?.a }).toEqual(expectPolled[i]);
       i++;
     }
 
-    const maxHeap = new MaxHeap<{ key: number; a: string }>({comparator: (a, b) => b.key - a.key});
-    maxHeap.add({key: 1, a: 'a1'});
-    maxHeap.add({key: 6, a: 'a6'});
-    maxHeap.add({key: 5, a: 'a5'});
-    maxHeap.add({key: 2, a: 'a2'});
-    maxHeap.add({key: 0, a: 'a0'});
-    maxHeap.add({key: 9, a: 'a9'});
-    expect(maxHeap.peek()).toEqual({a: 'a9', key: 9});
-    expect(maxHeap.toArray().map(item => ({a: item.a}))).toEqual([{a: 'a9'}, {a: 'a2'}, {a: 'a6'}, {a: 'a1'}, {a: 'a0'}, {a: 'a5'}]);
-    const maxExpectPolled = [{a: 'a9'}, {a: 'a6'}, {a: 'a5'}, {a: 'a2'}, {a: 'a1'}, {a: 'a0'}];
+    const maxHeap = new MaxHeap<{ key: number; a: string }>({ comparator: (a, b) => b.key - a.key });
+    maxHeap.add({ key: 1, a: 'a1' });
+    maxHeap.add({ key: 6, a: 'a6' });
+    maxHeap.add({ key: 5, a: 'a5' });
+    maxHeap.add({ key: 2, a: 'a2' });
+    maxHeap.add({ key: 0, a: 'a0' });
+    maxHeap.add({ key: 9, a: 'a9' });
+    expect(maxHeap.peek()).toEqual({ a: 'a9', key: 9 });
+    expect(maxHeap.toArray().map(item => ({ a: item.a }))).toEqual([
+      { a: 'a9' },
+      { a: 'a2' },
+      { a: 'a6' },
+      { a: 'a1' },
+      { a: 'a0' },
+      { a: 'a5' }
+    ]);
+    const maxExpectPolled = [{ a: 'a9' }, { a: 'a6' }, { a: 'a5' }, { a: 'a2' }, { a: 'a1' }, { a: 'a0' }];
     let maxI = 0;
     while (maxHeap.size > 0) {
-      expect({a: maxHeap.poll()?.a}).toEqual(maxExpectPolled[maxI]);
+      expect({ a: maxHeap.poll()?.a }).toEqual(maxExpectPolled[maxI]);
       maxI++;
     }
   });

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

@@ -1,11 +1,11 @@
-import {Comparator, MaxHeap} from '../../../../src';
+import { Comparator, MaxHeap } from '../../../../src';
 
 describe('MaxHeap', () => {
   const numberComparator: Comparator<number> = (a, b) => b - a;
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap({comparator: numberComparator});
+    maxHeap = new MaxHeap({ comparator: numberComparator });
   });
 
   it('add and poll elements in descending order', () => {

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

@@ -1,11 +1,11 @@
-import {Comparator, MinHeap} from '../../../../src';
+import { Comparator, MinHeap } from '../../../../src';
 
 describe('MinHeap', () => {
   const numberComparator: Comparator<number> = (a, b) => a - b;
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap({comparator: numberComparator});
+    minHeap = new MinHeap({ comparator: numberComparator });
   });
 
   it('add and poll elements in ascending order', () => {

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

@@ -1,4 +1,4 @@
-import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
+import { DoublyLinkedList, DoublyLinkedListNode } from '../../../../src';
 
 describe('DoublyLinkedListNode', () => {
   it('should DoublyLinkedListNode', () => {
@@ -370,9 +370,9 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should insert and manipulate objects with numeric properties', () => {
-    const obj1 = {keyA: 10};
-    const obj2 = {keyA: 20};
-    const obj3 = {keyA: 30};
+    const obj1 = { keyA: 10 };
+    const obj2 = { keyA: 20 };
+    const obj3 = { keyA: 30 };
 
     objectList.push(obj1);
     objectList.push(obj2);
@@ -380,7 +380,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
     expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
 
-    const newObj = {keyA: 25}; // Corrected newObj value
+    const newObj = { keyA: 25 }; // Corrected newObj value
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 

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

@@ -1,4 +1,4 @@
-import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
+import { SinglyLinkedList, SinglyLinkedListNode } from '../../../../src';
 
 describe('SinglyLinkedListNode', () => {
   it('should SinglyLinkedList', () => {
@@ -366,9 +366,9 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 
   it('should insert and manipulate objects with numeric properties', () => {
-    const obj1 = {keyA: 1};
-    const obj2 = {keyA: 2};
-    const obj3 = {keyA: 3};
+    const obj1 = { keyA: 1 };
+    const obj2 = { keyA: 2 };
+    const obj3 = { keyA: 3 };
 
     objectList.push(obj1);
     objectList.push(obj2);
@@ -376,7 +376,7 @@ describe('SinglyLinkedList Operation Test', () => {
 
     expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
 
-    const newObj = {keyA: 2.5}; // Corrected newObj value
+    const newObj = { keyA: 2.5 }; // Corrected newObj value
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 

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

@@ -1,4 +1,4 @@
-import {SkipList} from '../../../../src';
+import { SkipList } from '../../../../src';
 
 describe('SkipList', () => {
   let skipList: SkipList<number, string>;

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

@@ -1,10 +1,10 @@
-import {MatrixNTI2D} from '../../../../src';
+import { MatrixNTI2D } from '../../../../src';
 
 describe('MatrixNTI2D', () => {
   it('should initialize a matrix with rows and columns', () => {
     const numRows = 3;
     const numCols = 4;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
 
     expect(matrix.toArray().length).toBe(numRows);
     expect(matrix.toArray()[0].length).toBe(numCols);
@@ -14,7 +14,7 @@ describe('MatrixNTI2D', () => {
     const numRows = 3;
     const numCols = 4;
     const initialValue = 42;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols, initialVal: initialValue});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: initialValue });
 
     const matrixArray = matrix.toArray();
     for (let i = 0; i < numRows; i++) {
@@ -27,7 +27,7 @@ describe('MatrixNTI2D', () => {
   it('should initialize all elements with 0 if no initial value is provided', () => {
     const numRows = 3;
     const numCols = 4;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
 
     const matrixArray = matrix.toArray();
     for (let i = 0; i < numRows; i++) {
@@ -40,7 +40,7 @@ describe('MatrixNTI2D', () => {
   it('should convert the matrix to a two-dimensional array', () => {
     const numRows = 2;
     const numCols = 3;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols, initialVal: 1});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: 1 });
 
     const matrixArray = matrix.toArray();
     expect(matrixArray.length).toBe(numRows);

package/test/unit/data-structures/matrix/matrix2d.test.ts

@@ -1,5 +1,5 @@
-import {Matrix2D, Vector2D} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { Matrix2D, Vector2D } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 describe('Matrix2D', () => {
@@ -288,7 +288,7 @@ describe('Matrix2D', () => {
     const vector = new Vector2D(2, 3);
     const result = Matrix2D.multiplyByVector(matrix, vector);
     isDebug && console.log(JSON.stringify(result));
-    expect(result).toEqual({x: 17, y: 35, w: 1});
+    expect(result).toEqual({ x: 17, y: 35, w: 1 });
   });
 
   it('should correctly create a view matrix', () => {

package/test/unit/data-structures/matrix/navigator.test.ts

@@ -1,5 +1,5 @@
-import {Character, Navigator, NavigatorParams, Turning} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { Character, Navigator, NavigatorParams, Turning } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 const exampleMatrix: number[][] = [

package/test/unit/data-structures/matrix/vector2d.test.ts

@@ -1,4 +1,4 @@
-import {Vector2D} from '../../../../src';
+import { Vector2D } from '../../../../src';
 
 describe('Vector2D', () => {
   it('should create a vector with default values', () => {

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

@@ -1,4 +1,4 @@
-import {MaxPriorityQueue} from '../../../../src';
+import { MaxPriorityQueue } from '../../../../src';
 
 describe('MaxPriorityQueue Operation Test', () => {
   it('should add elements and maintain heap property', () => {
@@ -16,9 +16,9 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({comparator: (a, b) => b.keyA - a.keyA});
-    priorityQueue.refill([{keyA: 5}, {keyA: 3}, {keyA: 1}]);
-    priorityQueue.add({keyA: 7});
+    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({ comparator: (a, b) => b.keyA - a.keyA });
+    priorityQueue.refill([{ keyA: 5 }, { keyA: 3 }, { keyA: 1 }]);
+    priorityQueue.add({ keyA: 7 });
 
     expect(priorityQueue.poll()?.keyA).toBe(7);
     expect(priorityQueue.poll()?.keyA).toBe(5);
@@ -52,7 +52,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>({nodes: array, comparator: (a, b) => b - a});
+    const heap = MaxPriorityQueue.heapify<number>({ nodes: array, comparator: (a, b) => b - a });
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -62,8 +62,8 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should correctly heapify an object array', () => {
-    const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
+    const nodes = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({ nodes: nodes, comparator: (a, b) => b.keyA - a.keyA });
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);

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

@@ -1,4 +1,4 @@
-import {MinPriorityQueue} from '../../../../src';
+import { MinPriorityQueue } from '../../../../src';
 
 describe('MinPriorityQueue Operation Test', () => {
   it('should check if a node exists in the queue', () => {