data-structure-typed 1.49.4 → 1.49.5

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

@@ -33,24 +33,22 @@ describe('Overall BinaryTree Test', () => {
     objBST.add([11, { key: 11, keyA: 11 }]);
     objBST.add([3, { key: 3, keyA: 3 }]);
 
-    objBST.addMany(
-      [
-        [15, { key: 15, keyA: 15 }],
-        [1, { key: 1, keyA: 1 }],
-        [8, { key: 8, keyA: 8 }],
-        [13, { key: 13, keyA: 13 }],
-        [16, { key: 16, keyA: 16 }],
-        [2, { key: 2, keyA: 2 }],
-        [6, { key: 6, keyA: 6 }],
-        [9, { key: 9, keyA: 9 }],
-        [12, { key: 12, keyA: 12 }],
-        [14, { key: 14, keyA: 14 }],
-        [4, { key: 4, keyA: 4 }],
-        [7, { key: 7, keyA: 7 }],
-        [10, { key: 10, keyA: 10 }],
-        [5, { key: 5, keyA: 5 }]
-      ]
-    );
+    objBST.addMany([
+      [15, { key: 15, keyA: 15 }],
+      [1, { key: 1, keyA: 1 }],
+      [8, { key: 8, keyA: 8 }],
+      [13, { key: 13, keyA: 13 }],
+      [16, { key: 16, keyA: 16 }],
+      [2, { key: 2, keyA: 2 }],
+      [6, { key: 6, keyA: 6 }],
+      [9, { key: 9, keyA: 9 }],
+      [12, { key: 12, keyA: 12 }],
+      [14, { key: 14, keyA: 14 }],
+      [4, { key: 4, keyA: 4 }],
+      [7, { key: 7, keyA: 7 }],
+      [10, { key: 10, keyA: 10 }],
+      [5, { key: 5, keyA: 5 }]
+    ]);
 
     objBST.delete(11);
 

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

@@ -501,9 +501,9 @@ describe('RedBlackTree', () => {
     expect(tree.isAVLBalanced()).toBe(true);
 
     tree.clear();
-    tree.addMany([10, 20, 30, 40, 50, 60])
+    tree.addMany([10, 20, 30, 40, 50, 60]);
     expect(tree.isAVLBalanced()).toBe(false);
-  })
+  });
 });
 
 describe('RedBlackTree iterative methods test', () => {
@@ -537,13 +537,20 @@ describe('RedBlackTree iterative methods test', () => {
   test('filter should return a new tree with filtered elements', () => {
     const filteredTree = rbTree.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
-    expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
+    expect([...filteredTree]).toEqual([
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   test('map should return a new tree with modified elements', () => {
     const mappedTree = rbTree.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
-    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+    expect([...mappedTree]).toEqual([
+      [1, '2'],
+      [2, '4'],
+      [3, '6']
+    ]);
   });
 
   test('reduce should accumulate values', () => {
@@ -558,6 +565,10 @@ describe('RedBlackTree iterative methods test', () => {
     }
 
     expect(entries.length).toBe(3);
-    expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+    expect(entries).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
-});
+});

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

@@ -15,21 +15,30 @@ describe('TreeMultimap count', () => {
   let tm: TreeMultimap<number>;
   beforeEach(() => {
     tm = new TreeMultimap<number>();
-
-  })
+  });
   it('Should added isolated node count ', () => {
-    tm.addMany([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]);
+    tm.addMany([
+      [1, 1],
+      [2, 2],
+      [3, 3],
+      [4, 4],
+      [5, 5]
+    ]);
     const newNode = new TreeMultimapNode(3, 33, 10);
     tm.add(newNode);
-    expect(tm.count).toBe(15)
-  })
+    expect(tm.count).toBe(15);
+  });
 
   it('Should count', () => {
-    tm.addMany([[1, 1], [2, 2], [3, 3]]);
-    tm.lesserOrGreaterTraverse(node => node.count += 2, CP.gt, 1);
-    expect(tm.count).toBe(7)
-  })
-})
+    tm.addMany([
+      [1, 1],
+      [2, 2],
+      [3, 3]
+    ]);
+    tm.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 1);
+    expect(tm.count).toBe(7);
+  });
+});
 
 describe('TreeMultimap operations test1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
@@ -256,7 +265,7 @@ describe('TreeMultimap operations test1', () => {
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
     objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
     objTreeMultimap.add([3, { key: 3, keyA: 3 }]);
-    const values: [number, { key: number, keyA: number }][] = [
+    const values: [number, { key: number; keyA: number }][] = [
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
       [8, { key: 8, keyA: 8 }],
@@ -273,9 +282,7 @@ describe('TreeMultimap operations test1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objTreeMultimap.addMany(
-      values
-    );
+    objTreeMultimap.addMany(values);
 
     expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
 
@@ -529,9 +536,7 @@ describe('TreeMultimap operations test recursively1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objTreeMultimap.addMany(
-      values
-    );
+    objTreeMultimap.addMany(values);
 
     expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
 
@@ -632,13 +637,20 @@ describe('TreeMultimap iterative methods test', () => {
   test('filter should return a new tree with filtered elements', () => {
     const filteredTree = treeMM.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
-    expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
+    expect([...filteredTree]).toEqual([
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   test('map should return a new tree with modified elements', () => {
     const mappedTree = treeMM.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
-    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+    expect([...mappedTree]).toEqual([
+      [1, '2'],
+      [2, '4'],
+      [3, '6']
+    ]);
   });
 
   test('reduce should accumulate values', () => {
@@ -653,11 +665,15 @@ describe('TreeMultimap iterative methods test', () => {
     }
 
     expect(entries.length).toBe(3);
-    expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+    expect(entries).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   test('should clone work well', () => {
-    expect(treeMM.count).toBe(21)
+    expect(treeMM.count).toBe(21);
     const cloned = treeMM.clone();
     expect(cloned.root?.left?.key).toBe(1);
     expect(cloned.root?.right?.value).toBe('c');

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

@@ -378,11 +378,61 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
       expect(predecessor).toBeInstanceOf(Array);
       expect(predecessor.length).toBe(9);
-      expect(predecessor[0]).toEqual([vertex2, undefined, vertex2, undefined, vertex3, undefined, vertex4, undefined, undefined]);
-      expect(predecessor[1]).toEqual([undefined, vertex1, undefined, vertex1, vertex3, undefined, vertex4, undefined, vertex1]);
-      expect(predecessor[5]).toEqual([undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined]);
-      expect(predecessor[7]).toEqual([undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined]);
-      expect(predecessor[8]).toEqual([vertex7, vertex7, vertex7, vertex7, vertex7, undefined, undefined, undefined, vertex7]);
+      expect(predecessor[0]).toEqual([
+        vertex2,
+        undefined,
+        vertex2,
+        undefined,
+        vertex3,
+        undefined,
+        vertex4,
+        undefined,
+        undefined
+      ]);
+      expect(predecessor[1]).toEqual([
+        undefined,
+        vertex1,
+        undefined,
+        vertex1,
+        vertex3,
+        undefined,
+        vertex4,
+        undefined,
+        vertex1
+      ]);
+      expect(predecessor[5]).toEqual([
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      ]);
+      expect(predecessor[7]).toEqual([
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      ]);
+      expect(predecessor[8]).toEqual([
+        vertex7,
+        vertex7,
+        vertex7,
+        vertex7,
+        vertex7,
+        undefined,
+        undefined,
+        undefined,
+        vertex7
+      ]);
     }
 
     const dijkstraRes12tt = myGraph.dijkstra(1, 2, true, true);
@@ -622,7 +672,10 @@ describe('DirectedGraph iterative Methods', () => {
 
   test('filter should return vertexMap that satisfy the condition', () => {
     const filtered = graph.filter((value, vertex) => vertex === 'A' || vertex === 'B');
-    expect(filtered).toEqual([["A", undefined], ["B", undefined]]);
+    expect(filtered).toEqual([
+      ['A', undefined],
+      ['B', undefined]
+    ]);
   });
 
   test('map should apply a function to each vertex and return a new array', () => {
@@ -637,53 +690,53 @@ describe('DirectedGraph iterative Methods', () => {
 
   test('Removing an edge of a DirectedGraph should delete additional edges', () => {
     const dg = new DirectedGraph();
-    dg.addVertex('hello')
-    dg.addVertex('hi')
-    dg.addVertex('hey')
-    dg.addEdge('hello', 'hi')
-    dg.addEdge('hello', 'hey')
-    expect(dg.getEdge('hello', 'hi')?.src).toBe('hello')
-    expect(dg.getEdge('hello', 'hi')?.dest).toBe('hi')
-    expect(dg.getEdge('hello', 'hey')?.src).toBe('hello')
-    expect(dg.getEdge('hello', 'hey')?.dest).toBe('hey')
-    dg.deleteEdge('hello', 'hi')
-    expect(dg.getEdge('hello', 'hi')).toBe(undefined)
-    expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(DirectedEdge)
-    expect(dg.incomingEdgesOf("Hi")).toEqual([])
+    dg.addVertex('hello');
+    dg.addVertex('hi');
+    dg.addVertex('hey');
+    dg.addEdge('hello', 'hi');
+    dg.addEdge('hello', 'hey');
+    expect(dg.getEdge('hello', 'hi')?.src).toBe('hello');
+    expect(dg.getEdge('hello', 'hi')?.dest).toBe('hi');
+    expect(dg.getEdge('hello', 'hey')?.src).toBe('hello');
+    expect(dg.getEdge('hello', 'hey')?.dest).toBe('hey');
+    dg.deleteEdge('hello', 'hi');
+    expect(dg.getEdge('hello', 'hi')).toBe(undefined);
+    expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(DirectedEdge);
+    expect(dg.incomingEdgesOf('Hi')).toEqual([]);
   });
 
   test('Removing a vertex of a DirectedGraph should delete additional edges', () => {
     const graph = new DirectedGraph();
 
-    graph.addVertex("Hello");
-    graph.addVertex("Hi");
+    graph.addVertex('Hello');
+    graph.addVertex('Hi');
 
-    graph.addEdge("Hello", "Hi");
-    graph.deleteVertex("Hello");
+    graph.addEdge('Hello', 'Hi');
+    graph.deleteVertex('Hello');
 
-    expect(graph.incomingEdgesOf("Hi")).toEqual([]);
-  })
+    expect(graph.incomingEdgesOf('Hi')).toEqual([]);
+  });
 
   test('Removing a vertex from a DirectedGraph should remove its edges', () => {
     const dg = new DirectedGraph();
-    dg.addVertex('hello')
-    dg.addVertex('world')
-    dg.addVertex('earth')
+    dg.addVertex('hello');
+    dg.addVertex('world');
+    dg.addVertex('earth');
 
-    dg.addEdge('hello', 'world')
-    dg.addEdge('hello', 'earth')
-    dg.addEdge('world', 'earth')
+    dg.addEdge('hello', 'world');
+    dg.addEdge('hello', 'earth');
+    dg.addEdge('world', 'earth');
 
     expect(dg.getEdge('hello', 'world')?.src).toBe('hello');
-    expect(dg.edgeSet().length).toBe(3)
-    expect(dg.edgeSet()[0].dest).toBe('world')
+    expect(dg.edgeSet().length).toBe(3);
+    expect(dg.edgeSet()[0].dest).toBe('world');
 
-    dg.deleteVertex('hello')
-    expect(dg.edgeSet().length).toBe(1)
-    expect(dg.edgeSet()?.[0].src).toBe('world')
+    dg.deleteVertex('hello');
+    expect(dg.edgeSet().length).toBe(1);
+    expect(dg.edgeSet()?.[0].src).toBe('world');
 
     expect(dg.getEdge('hello', 'world')).toBe(undefined);
-  })
+  });
 });
 
 describe('DirectedGraph getCycles', () => {
@@ -702,8 +755,8 @@ describe('DirectedGraph getCycles', () => {
     graph.addEdge('E', 'B');
     const cycles = graph.getCycles();
     expect(cycles.length).toBe(1);
-    expect(cycles[0]).toEqual(["B", "D", "E"]);
-  })
+    expect(cycles[0]).toEqual(['B', 'D', 'E']);
+  });
 
   test('should simple cycles graph getCycles return correct result', () => {
     const graph = new DirectedGraph();
@@ -719,8 +772,11 @@ describe('DirectedGraph getCycles', () => {
     graph.addEdge('A', 'D');
     graph.addEdge('D', 'C');
     const cycles = graph.getCycles();
-    expect(cycles.length).toBe(2)
-    expect(cycles).toEqual([["A", "B", "C"], ["A", "D", "C"]])
+    expect(cycles.length).toBe(2);
+    expect(cycles).toEqual([
+      ['A', 'B', 'C'],
+      ['A', 'D', 'C']
+    ]);
   });
 
   test('should 3 cycles graph getCycles return correct result', () => {
@@ -746,8 +802,11 @@ describe('DirectedGraph getCycles', () => {
     graph.addEdge('G', 'A');
 
     const cycles = graph.getCycles();
-    expect(cycles.length).toBe(3)
-    expect(cycles).toEqual([["A", "C", "G"], ["B", "D", "E"], ["B", "F", "E"]]);
+    expect(cycles.length).toBe(3);
+    expect(cycles).toEqual([
+      ['A', 'C', 'G'],
+      ['B', 'D', 'E'],
+      ['B', 'F', 'E']
+    ]);
   });
-})
-
+});

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

@@ -176,53 +176,52 @@ describe('UndirectedGraph', () => {
 
   test('Removing an edge of a UndirectedGraph should not delete additional edges', () => {
     const dg = new UndirectedGraph();
-    dg.addVertex('hello')
-    dg.addVertex('hi')
-    dg.addVertex('hey')
-    dg.addEdge('hello', 'hi')
-    dg.addEdge('hello', 'hey')
-    expect(dg.getEdge('hello', 'hi')?.vertexMap[0]).toBe('hello')
-    expect(dg.getEdge('hello', 'hi')?.vertexMap[1]).toBe('hi')
-    expect(dg.getEdge('hello', 'hey')?.vertexMap[0]).toBe('hello')
-    expect(dg.getEdge('hello', 'hey')?.vertexMap[1]).toBe('hey')
-    dg.deleteEdge('hello', 'hi')
-    expect(dg.getEdge('hello', 'hi')).toBe(undefined)
-    expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(UndirectedEdge)
+    dg.addVertex('hello');
+    dg.addVertex('hi');
+    dg.addVertex('hey');
+    dg.addEdge('hello', 'hi');
+    dg.addEdge('hello', 'hey');
+    expect(dg.getEdge('hello', 'hi')?.vertexMap[0]).toBe('hello');
+    expect(dg.getEdge('hello', 'hi')?.vertexMap[1]).toBe('hi');
+    expect(dg.getEdge('hello', 'hey')?.vertexMap[0]).toBe('hello');
+    expect(dg.getEdge('hello', 'hey')?.vertexMap[1]).toBe('hey');
+    dg.deleteEdge('hello', 'hi');
+    expect(dg.getEdge('hello', 'hi')).toBe(undefined);
+    expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(UndirectedEdge);
   });
 
-
   test('Removing a vertex of a DirectedGraph should delete additional edges', () => {
     const graph = new UndirectedGraph();
 
-    graph.addVertex("Hello");
-    graph.addVertex("Hi");
+    graph.addVertex('Hello');
+    graph.addVertex('Hi');
 
-    graph.addEdge("Hello", "Hi");
-    graph.deleteVertex("Hello");
+    graph.addEdge('Hello', 'Hi');
+    graph.deleteVertex('Hello');
 
-    expect(graph.edgesOf("Hi")).toEqual([]);
-  })
+    expect(graph.edgesOf('Hi')).toEqual([]);
+  });
 
   test('Removing a vertex from a UndirectedGraph should remove its edges', () => {
     const dg = new UndirectedGraph();
-    dg.addVertex('hello')
-    dg.addVertex('world')
-    dg.addVertex('earth')
+    dg.addVertex('hello');
+    dg.addVertex('world');
+    dg.addVertex('earth');
 
-    dg.addEdge('hello', 'world')
-    dg.addEdge('hello', 'earth')
-    dg.addEdge('world', 'earth')
+    dg.addEdge('hello', 'world');
+    dg.addEdge('hello', 'earth');
+    dg.addEdge('world', 'earth');
 
     expect(dg.getEdge('hello', 'world')?.vertexMap[0]).toBe('hello');
-    expect(dg.edgeSet().length).toBe(3)
-    expect(dg.edgeSet()[0].vertexMap).toEqual(['hello', 'world'])
+    expect(dg.edgeSet().length).toBe(3);
+    expect(dg.edgeSet()[0].vertexMap).toEqual(['hello', 'world']);
 
-    dg.deleteVertex('hello')
-    expect(dg.edgeSet().length).toBe(1)
-    expect(dg.edgeSet()?.[0].vertexMap[0]).toBe('world')
+    dg.deleteVertex('hello');
+    expect(dg.edgeSet().length).toBe(1);
+    expect(dg.edgeSet()?.[0].vertexMap[0]).toBe('world');
 
     expect(dg.getEdge('hello', 'world')).toBe(undefined);
-  })
+  });
 });
 
 describe('cycles, strongly connected components, bridges, articular points in UndirectedGraph', () => {
@@ -258,8 +257,7 @@ describe('cycles, strongly connected components, bridges, articular points in Un
   expect(lowMap.size).toBe(8);
 });
 
-it("Should return Infinity if dest is not found", () => {
-
+it('Should return Infinity if dest is not found', () => {
   const graph = new UndirectedGraph<string>();
 
   for (let i = 0; i < 3; ++i) {
@@ -291,8 +289,12 @@ describe('UndirectedGraph getCycles', () => {
     graph.addEdge('E', 'B');
     const cycles = graph.getCycles();
     expect(cycles.length).toBe(3);
-    expect(cycles).toEqual([["A", "B", "D", "C"], ["A", "B", "E", "D", "C"], ["B", "D", "E"]]);
-  })
+    expect(cycles).toEqual([
+      ['A', 'B', 'D', 'C'],
+      ['A', 'B', 'E', 'D', 'C'],
+      ['B', 'D', 'E']
+    ]);
+  });
 
   test('should simple cycles graph getCycles return correct result', () => {
     const graph = new UndirectedGraph();
@@ -308,8 +310,12 @@ describe('UndirectedGraph getCycles', () => {
     graph.addEdge('A', 'D');
     graph.addEdge('D', 'C');
     const cycles = graph.getCycles();
-    expect(cycles.length).toBe(3)
-    expect(cycles).toEqual([["A", "B", "C"], ["A", "B", "C", "D"], ["A", "C", "D"]])
+    expect(cycles.length).toBe(3);
+    expect(cycles).toEqual([
+      ['A', 'B', 'C'],
+      ['A', 'B', 'C', 'D'],
+      ['A', 'C', 'D']
+    ]);
   });
 
   test('should 3 cycles graph getCycles return correct result', () => {
@@ -335,7 +341,18 @@ describe('UndirectedGraph getCycles', () => {
     graph.addEdge('G', 'A');
 
     const cycles = graph.getCycles();
-    expect(cycles.length).toBe(10)
-    expect(cycles).toEqual([["A", "B", "D", "C"], ["A", "B", "D", "C", "G"], ["A", "B", "E", "D", "C"], ["A", "B", "E", "D", "C", "G"], ["A", "B", "F", "E", "D", "C"], ["A", "B", "F", "E", "D", "C", "G"], ["A", "C", "G"], ["B", "D", "E"], ["B", "D", "E", "F"], ["B", "E", "F"]]);
+    expect(cycles.length).toBe(10);
+    expect(cycles).toEqual([
+      ['A', 'B', 'D', 'C'],
+      ['A', 'B', 'D', 'C', 'G'],
+      ['A', 'B', 'E', 'D', 'C'],
+      ['A', 'B', 'E', 'D', 'C', 'G'],
+      ['A', 'B', 'F', 'E', 'D', 'C'],
+      ['A', 'B', 'F', 'E', 'D', 'C', 'G'],
+      ['A', 'C', 'G'],
+      ['B', 'D', 'E'],
+      ['B', 'D', 'E', 'F'],
+      ['B', 'E', 'F']
+    ]);
   });
-})
+});