data-structure-typed 1.48.1 → 1.48.3

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

@@ -252,7 +252,7 @@ describe('TreeMultimap operations test1', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
+    const objTreeMultimap = new TreeMultimap<number, { key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
     objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
     objTreeMultimap.add([3, { key: 3, keyA: 3 }]);
@@ -508,7 +508,7 @@ describe('TreeMultimap operations test recursively1', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
+    const objTreeMultimap = new TreeMultimap<number, { key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
     objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
     objTreeMultimap.add([3, { key: 3, keyA: 3 }]);
@@ -544,7 +544,7 @@ describe('TreeMultimap operations test recursively1', () => {
 });
 
 describe('TreeMultimap Performance test', function () {
-  const treeMS = new TreeMultimap<TreeMultimapNode<number>>();
+  const treeMS = new TreeMultimap<number, number>();
   const inputSize = 100000; // Adjust input sizes as needed
 
   beforeEach(() => {
@@ -602,9 +602,9 @@ describe('TreeMultimap Performance test', function () {
 });
 
 describe('TreeMultimap iterative methods test', () => {
-  let treeMM: TreeMultimap<string>;
+  let treeMM: TreeMultimap<number, string>;
   beforeEach(() => {
-    treeMM = new TreeMultimap<string>();
+    treeMM = new TreeMultimap<number, string>();
     treeMM.add([1, 'a'], 10);
     treeMM.add([2, 'b'], 10);
     treeMM.add([3, 'c'], 1);
@@ -619,30 +619,30 @@ describe('TreeMultimap iterative methods test', () => {
 
   test('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    treeMM.forEach((entry) => {
-      mockCallback(entry);
+    treeMM.forEach((value, key) => {
+      mockCallback(value, key);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0][0]).toEqual([1, 'a']);
-    expect(mockCallback.mock.calls[1][0]).toEqual([2, 'b']);
-    expect(mockCallback.mock.calls[2][0]).toEqual([3, 'c']);
+    expect(mockCallback.mock.calls[0]).toEqual(['a', 1]);
+    expect(mockCallback.mock.calls[1]).toEqual(['b', 2]);
+    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
   });
 
   test('filter should return a new tree with filtered elements', () => {
-    const filteredTree = treeMM.filter(([key]) => key > 1);
+    const filteredTree = treeMM.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
   });
 
   test('map should return a new tree with modified elements', () => {
-    const mappedTree = treeMM.map(([key]) => (key * 2).toString());
+    const mappedTree = treeMM.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
   });
 
   test('reduce should accumulate values', () => {
-    const sum = treeMM.reduce((acc, [key]) => acc + key, 0);
+    const sum = treeMM.reduce((acc, value, key) => acc + key, 0);
     expect(sum).toBe(6);
   });
 
@@ -665,11 +665,11 @@ describe('TreeMultimap iterative methods test', () => {
 
   test('should keys', () => {
     const keys = treeMM.keys();
-    expect(keys).toEqual([1, 2, 3]);
+    expect([...keys]).toEqual([1, 2, 3]);
   });
 
   test('should values', () => {
     const values = treeMM.values();
-    expect(values).toEqual(['a', 'b', 'c']);
+    expect([...values]).toEqual(['a', 'b', 'c']);
   });
 });

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

@@ -616,22 +616,22 @@ describe('DirectedGraph iterative Methods', () => {
 
   test('forEach should apply a function to each vertex', () => {
     const result: VertexKey[] = [];
-    graph.forEach(vertex => result.push(vertex[0]));
+    graph.forEach((value, key) => key && result.push(key));
     expect(result).toEqual(vertices);
   });
 
   test('filter should return vertices that satisfy the condition', () => {
-    const filtered = graph.filter(vertex => vertex[0] === 'A' || vertex[0] === 'B');
+    const filtered = graph.filter((value, vertex) => vertex === 'A' || vertex === 'B');
     expect(filtered).toEqual([["A", undefined], ["B", undefined]]);
   });
 
   test('map should apply a function to each vertex and return a new array', () => {
-    const mapped = graph.map(vertex => vertex[0] + '_mapped');
+    const mapped = graph.map((value, vertex) => vertex + '_mapped');
     expect(mapped).toEqual(vertices.map(v => v + '_mapped'));
   });
 
   test('reduce should accumulate a value based on each vertex', () => {
-    const concatenated = graph.reduce((acc, vertex) => acc + vertex[0], '');
+    const concatenated = graph.reduce((acc, value, key) => acc + key, '');
     expect(concatenated).toBe(vertices.join(''));
   });
 });

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

@@ -548,10 +548,10 @@ describe('LinkedHashMap setMany, keys, values', () => {
   })
 
   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])
   });
 });

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

@@ -397,3 +397,31 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(shiftedObj).toBe(obj1);
   });
 });
+
+
+describe('iterable methods', () => {
+  it('should forEach, some, every, filter, map, reduce of the deque', () => {
+    const dl = new DoublyLinkedList<number>()
+    dl.push(1);
+    dl.push(2);
+    dl.push(3);
+
+    const mockCallback = jest.fn();
+    dl.forEach((element) => {
+      mockCallback(element);
+    });
+
+    expect(mockCallback.mock.calls.length).toBe(3);
+    expect(mockCallback.mock.calls[0]).toEqual([1]);
+    expect(mockCallback.mock.calls[1]).toEqual([2]);
+    expect(mockCallback.mock.calls[2]).toEqual([3]);
+
+    expect(dl.every(element => element > 0)).toBe(true);
+    expect(dl.every(element => element > 1)).toBe(false);
+    expect(dl.some(element => element > 2)).toBe(true);
+
+    expect([...dl.filter(element => element > 2)]).toEqual([3]);
+    expect([...dl.map(element => element * 2)]).toEqual([2, 4, 6]);
+    expect(dl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
+  });
+});

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

@@ -471,3 +471,28 @@ describe('SinglyLinkedList', () => {
     expect(list1.reduce((acc, value) => acc + value, 0)).toEqual(6);
   });
 });
+
+
+describe('iterable methods', () => {
+  it('should forEach, some, every, filter, map, reduce of the deque', () => {
+    const sl = new SinglyLinkedList<number>([1, 2, 3])
+
+    const mockCallback = jest.fn();
+    sl.forEach((element) => {
+      mockCallback(element);
+    });
+
+    expect(mockCallback.mock.calls.length).toBe(3);
+    expect(mockCallback.mock.calls[0]).toEqual([1]);
+    expect(mockCallback.mock.calls[1]).toEqual([2]);
+    expect(mockCallback.mock.calls[2]).toEqual([3]);
+
+    expect(sl.every(element => element > 0)).toBe(true);
+    expect(sl.every(element => element > 1)).toBe(false);
+    expect(sl.some(element => element > 2)).toBe(true);
+
+    expect([...sl.filter(element => element > 2)]).toEqual([3]);
+    expect([...sl.map(element => element * 2)]).toEqual([2, 4, 6]);
+    expect(sl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
+  });
+});

package/test/unit/data-structures/queue/deque.test.ts

@@ -447,4 +447,29 @@ describe('Deque', () => {
     });
   });
 
+  describe('iterable methods', () => {
+    it('should forEach, some, every, filter, map, reduce of the deque', () => {
+      deque.push(1);
+      deque.push(2);
+      deque.push(3);
+
+      const mockCallback = jest.fn();
+      deque.forEach((element) => {
+        mockCallback(element);
+      });
+
+      expect(mockCallback.mock.calls.length).toBe(3);
+      expect(mockCallback.mock.calls[0]).toEqual([1]);
+      expect(mockCallback.mock.calls[1]).toEqual([2]);
+      expect(mockCallback.mock.calls[2]).toEqual([3]);
+
+      expect(deque.every(element => element > 0)).toBe(true);
+      expect(deque.every(element => element > 1)).toBe(false);
+      expect(deque.some(element => element > 2)).toBe(true);
+
+      expect([...deque.filter(element => element > 2)]).toEqual([3]);
+      expect([...deque.map(element => element * 2)]).toEqual([2, 4, 6]);
+      expect(deque.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
+    });
+  });
 });

package/test/unit/unrestricted-interconversion.test.ts

@@ -145,7 +145,7 @@ describe('conversions', () => {
     expect(dq.size).toBe(10);
     isDebug && dq.print();
     const entries = dq.map((el, i) => <[number, string]>[i, el]);
-    const avl = new AVLTree<string>(entries);
+    const avl = new AVLTree<number, string>(entries);
     expect(avl.size).toBe(10)
     isDebug && avl.print();
   })