data-structure-typed 1.49.3 → 1.49.5

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

@@ -176,40 +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.addEdge('Hello', 'Hi');
+    graph.deleteVertex('Hello');
+
+    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', () => {
@@ -245,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) {
@@ -278,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();
@@ -295,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', () => {
@@ -322,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']
+    ]);
   });
-})
+});

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

@@ -54,7 +54,6 @@ describe('HashMap Test1', () => {
     hashMap.set('one', 1);
     hashMap.set('two', 2);
     hashMap.set('three', 3);
-
   });
 
   it('should resize the table when load factor is exceeded', () => {
@@ -181,7 +180,6 @@ describe('HashMap Test2', () => {
     }
     compareHashMaps(hashMap, stdMap);
   });
-
 });
 
 describe('HashMap for coordinate object keys', () => {
@@ -207,30 +205,39 @@ describe('HashMap for coordinate object keys', () => {
 
   test('delete elements in hash map', () => {
     for (let i = 0; i < 1000; i++) {
-      if (i === 500) expect(hashMap.size).toBe(500)
+      if (i === 500) expect(hashMap.size).toBe(500);
       const codObj = codObjs[i];
       if (codObj) hashMap.delete(codObj);
     }
     expect(hashMap.size).toBe(0);
   });
-
 });
 
 describe('HashMap setMany, keys, values', () => {
   const hm: HashMap<number, number> = new HashMap<number, number>();
 
   beforeEach(() => {
-    hm.clear()
-    hm.setMany([[2, 2], [3, 3], [4, 4], [5, 5]])
-    hm.setMany([[2, 2], [3, 3], [4, 4], [6, 6]])
-  })
+    hm.clear();
+    hm.setMany([
+      [2, 2],
+      [3, 3],
+      [4, 4],
+      [5, 5]
+    ]);
+    hm.setMany([
+      [2, 2],
+      [3, 3],
+      [4, 4],
+      [6, 6]
+    ]);
+  });
 
   test('keys', () => {
-    expect([...hm.keys()]).toEqual([2, 3, 4, 5, 6])
+    expect([...hm.keys()]).toEqual([2, 3, 4, 5, 6]);
   });
 
   test('values', () => {
-    expect([...hm.values()]).toEqual([2, 3, 4, 5, 6])
+    expect([...hm.values()]).toEqual([2, 3, 4, 5, 6]);
   });
 });
 
@@ -245,7 +252,7 @@ describe('HashMap HOF', () => {
   });
 
   test('every() returns true if all elements match the condition', () => {
-    expect(hashMap.every((value) => typeof value === 'string')).toBe(true);
+    expect(hashMap.every(value => typeof value === 'string')).toBe(true);
   });
 
   test('some() returns true if any element matches the condition', () => {
@@ -259,7 +266,7 @@ describe('HashMap HOF', () => {
   });
 
   test('map() should transform each element', () => {
-    const newHashMap = hashMap.map((value) => value.toUpperCase());
+    const newHashMap = hashMap.map(value => value.toUpperCase());
     expect(newHashMap.get('key1')).toBe('VALUE1');
   });
 
@@ -274,7 +281,6 @@ describe('HashMap HOF', () => {
   });
 });
 
-
 describe('LinkedHashMap Test1', () => {
   let hashMap: LinkedHashMap<string, number>;
 
@@ -368,7 +374,6 @@ describe('LinkedHashMap Test1', () => {
     // expect(hashMap.table[0].length).toBe(2);
   });
 
-
   // it('should handle number keys correctly', () => {
   //   const hm = new LinkedHashMap();
   //   hm.set(999, { a: '999Value' });
@@ -529,29 +534,65 @@ describe('LinkedHashMap for coordinate object keys', () => {
 
   test('delete elements in hash map', () => {
     for (let i = 0; i < 1000; i++) {
-      if (i === 500) expect(hashMap.size).toBe(500)
+      if (i === 500) expect(hashMap.size).toBe(500);
       const codObj = codObjs[i];
       if (codObj) hashMap.delete(codObj);
     }
     expect(hashMap.size).toBe(0);
   });
-
 });
 
 describe('LinkedHashMap setMany, keys, values', () => {
   const hm: LinkedHashMap<number, number> = new LinkedHashMap<number, number>();
 
   beforeEach(() => {
-    hm.clear()
-    hm.setMany([[2, 2], [3, 3], [4, 4], [5, 5]])
-    hm.setMany([[2, 2], [3, 3], [4, 4], [6, 6]])
-  })
+    hm.clear();
+    hm.setMany([
+      [2, 2],
+      [3, 3],
+      [4, 4],
+      [5, 5]
+    ]);
+    hm.setMany([
+      [2, 2],
+      [3, 3],
+      [4, 4],
+      [6, 6]
+    ]);
+  });
 
   test('keys', () => {
-    expect([...hm.keys()]).toEqual([2, 3, 4, 5, 6])
+    expect([...hm.keys()]).toEqual([2, 3, 4, 5, 6]);
   });
 
   test('values', () => {
-    expect([...hm.values()]).toEqual([2, 3, 4, 5, 6])
+    expect([...hm.values()]).toEqual([2, 3, 4, 5, 6]);
   });
-});
+
+  test('entries', () => {
+    expect([...hm.entries()]).toEqual([
+      [2, 2],
+      [3, 3],
+      [4, 4],
+      [5, 5],
+      [6, 6]
+    ]);
+  });
+
+  test('every', () => {
+    expect(hm.every(value => value > 4)).toBe(false);
+  });
+
+  test('some', () => {
+    expect(hm.some(value => value > 6)).toBe(false);
+  });
+
+  test('hasValue', () => {
+    expect(hm.hasValue(3)).toBe(true);
+    expect(hm.hasValue(7)).toBe(false);
+  });
+
+  test('print', () => {
+    hm.print();
+  });
+});

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

@@ -185,7 +185,6 @@ describe('HashTable performance', function () {
   });
 });
 
-
 describe('HashTable methods', () => {
   let hashTable: HashTable<string, string>;
 
@@ -215,7 +214,6 @@ describe('HashTable methods', () => {
   //   }
   // });
 
-
   test('filter should return a new HashTable with elements that satisfy the condition', () => {
     const filtered = hashTable.filter(([key]) => key.endsWith('1') || key.endsWith('3'));
 
@@ -237,6 +235,4 @@ describe('HashTable methods', () => {
 
     expect(result).toBe('-value5-value7-value3-value4-value6-value0-value2-value8-value1-value9');
   });
-
 });
-

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

@@ -1,7 +1,6 @@
 import { FibonacciHeap, MaxHeap, MinHeap } from '../../../../src';
 import { logBigOMetricsWrap } from '../../../utils';
 
-
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
     const minNumHeap = new MinHeap<number>();

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

@@ -50,17 +50,15 @@ describe('MinHeap', () => {
     expect(minHeap.isEmpty()).toBe(true);
   });
 
-
   const n = 100000;
 
   it('should push & dfs', () => {
     for (let i = 0; i < n; i++) {
       minHeap.add(i);
     }
-    expect(minHeap.dfs()[0]).toBe(0)
-    expect(minHeap.dfs()[999]).toBe(4126)
+    expect(minHeap.dfs()[0]).toBe(0);
+    expect(minHeap.dfs()[999]).toBe(4126);
   });
-
 });
 
 describe('Heap iterative methods', () => {
@@ -89,7 +87,10 @@ describe('Heap iterative methods', () => {
   });
 
   test('map method correctly maps elements', () => {
-    const result = heap.map(x => x / 10, (a: number, b: number) => a - b);
+    const result = heap.map(
+      x => x / 10,
+      (a: number, b: number) => a - b
+    );
     expect([...result]).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
   });
 

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

@@ -398,16 +398,15 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 });
 
-
 describe('iterable methods', () => {
   it('should forEach, some, every, filter, map, reduce of the deque', () => {
-    const dl = new DoublyLinkedList<number>()
+    const dl = new DoublyLinkedList<number>();
     dl.push(1);
     dl.push(2);
     dl.push(3);
 
     const mockCallback = jest.fn();
-    dl.forEach((element) => {
+    dl.forEach(element => {
       mockCallback(element);
     });
 
@@ -424,4 +423,31 @@ describe('iterable methods', () => {
     expect([...dl.map(element => element * 2)]).toEqual([2, 4, 6]);
     expect(dl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
   });
-});
+
+  test('values', () => {
+    const dl = new DoublyLinkedList<number>();
+    dl.push(1);
+    dl.push(2);
+    dl.push(3);
+    dl.delete(2);
+    dl.unshift(0);
+    dl.shift();
+    dl.pop();
+    dl.unshift(3);
+    expect([...dl.values()]).toEqual([3, 1]);
+  });
+
+  test('some', () => {
+    const dl = new DoublyLinkedList<number>();
+    dl.push(1);
+    dl.push(2);
+    dl.push(3);
+    dl.delete(2);
+    dl.unshift(0);
+    dl.shift();
+    dl.pop();
+    dl.unshift(3);
+    expect(dl.some(value => value > 1)).toBe(true);
+    expect(dl.some(value => value > 100)).toBe(false);
+  });
+});

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

@@ -472,13 +472,12 @@ describe('SinglyLinkedList', () => {
   });
 });
 
-
 describe('iterable methods', () => {
   it('should forEach, some, every, filter, map, reduce of the deque', () => {
-    const sl = new SinglyLinkedList<number>([1, 2, 3])
+    const sl = new SinglyLinkedList<number>([1, 2, 3]);
 
     const mockCallback = jest.fn();
-    sl.forEach((element) => {
+    sl.forEach(element => {
       mockCallback(element);
     });
 
@@ -495,4 +494,4 @@ describe('iterable methods', () => {
     expect([...sl.map(element => element * 2)]).toEqual([2, 4, 6]);
     expect(sl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
   });
-});
+});