data-structure-typed 2.2.0 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Standard data structure",
   "browser": "dist/umd/data-structure-typed.min.js",
   "umd:main": "dist/umd/data-structure-typed.min.js",
@@ -99,7 +99,7 @@
     "benchmark": "^2.1.4",
     "binary-tree-typed": "^1.54.3",
     "bst-typed": "^1.54.3",
-    "data-structure-typed": "^2.1.2",
+    "data-structure-typed": "^2.2.1",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",

package/src/data-structures/base/iterable-entry-base.ts

@@ -66,7 +66,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
   every(predicate: EntryCallback<K, V, boolean>, thisArg?: any): boolean {
     let index = 0;
     for (const item of this) {
-      if (!predicate.call(thisArg, item[0], item[1], index++, this)) {
+      if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
         return false;
       }
     }
@@ -83,7 +83,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
   some(predicate: EntryCallback<K, V, boolean>, thisArg?: any): boolean {
     let index = 0;
     for (const item of this) {
-      if (predicate.call(thisArg, item[0], item[1], index++, this)) {
+      if (predicate.call(thisArg, item[1], item[0], index++, this)) {
         return true;
       }
     }
@@ -100,7 +100,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
     let index = 0;
     for (const item of this) {
       const [key, value] = item;
-      callbackfn.call(thisArg, key, value, index++, this);
+      callbackfn.call(thisArg, value, key, index++, this);
     }
   }
 
@@ -115,7 +115,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
     let index = 0;
     for (const item of this) {
       const [key, value] = item;
-      if (callbackfn.call(thisArg, key, value, index++, this)) return item;
+      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
     }
     return;
   }

package/src/data-structures/binary-tree/avl-tree-counter.ts

@@ -411,7 +411,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
 
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, key, value, index++, this));
+      out.add(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -393,7 +393,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
   ): AVLTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, k, v, i++, this));
+    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
     return out;
   }
 

package/src/data-structures/binary-tree/avl-tree.ts

@@ -195,7 +195,9 @@ export class AVLTreeNode<K = any, V = any> {
  * 4. Order Preservation: Maintains the binary search tree property where left child values are less than the parent, and right child values are greater.
  * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
- * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.@example
+ * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
+ *
+ * @example
  * // Find elements in a range
  *     // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
  *     type Datum = { timestamp: Date; temperature: number };
@@ -403,7 +405,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     // Iterates in-order
     for (const [key, value] of this) {
       // `add` on the new tree will be O(log N) and will self-balance.
-      out.add(callback.call(thisArg, key, value, index++, this));
+      out.add(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/binary-tree.ts

@@ -203,6 +203,7 @@ export class BinaryTreeNode<K = any, V = any> {
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
+ *
  * @example
  * // determine loan approval using a decision tree
  *     // Decision tree structure
@@ -1673,7 +1674,7 @@ export class BinaryTree<K = any, V = any, R = any>
   filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): this {
     const out = this._createInstance<K, V, R>();
     let i = 0;
-    for (const [k, v] of this) if (predicate.call(thisArg, k, v, i++, this)) out.add([k, v]);
+    for (const [k, v] of this) if (predicate.call(thisArg, v, k, i++, this)) out.add([k, v]);
     return out;
   }
 
@@ -1696,7 +1697,7 @@ export class BinaryTree<K = any, V = any, R = any>
   ): BinaryTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(cb.call(thisArg, k, v, i++, this));
+    for (const [k, v] of this) out.add(cb.call(thisArg, v, k, i++, this));
     return out;
   }
 

package/src/data-structures/binary-tree/bst.ts

@@ -199,6 +199,7 @@ export class BSTNode<K = any, V = any> {
  * 5. Logarithmic Operations: Ideal operations like insertion, deletion, and searching are O(log n) time-efficient.
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
+ *
  * @example
  * // Merge 3 sorted datasets
  *     const dataset1 = new BST<number, string>([
@@ -908,7 +909,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     let index = 0;
     // Iterates in-order
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, key, value, index++, this));
+      out.add(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/red-black-tree.ts

@@ -186,6 +186,7 @@ export class RedBlackTreeNode<K = any, V = any> {
  * @template R
  * 1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high, but the query efficiency is slightly lower.
  * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
+ *
  * @example
  * // using Red-Black Tree as a price-based index for stock data
  *     // Define the structure of individual stock records
@@ -420,7 +421,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
 
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, key, value, index++, this));
+      out.add(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/tree-counter.ts

@@ -439,7 +439,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
 
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, key, value, index++, this));
+      out.add(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -183,6 +183,7 @@ export class TreeMultiMapNode<K = any, V = any> {
  * @template K
  * @template V
  * @template R
+ *
  * @example
  * // players ranked by score with their equipment
  *     type Equipment = {
@@ -503,7 +504,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
   ): RedBlackTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, k, v, i++, this));
+    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
     return out;
   }
 

package/src/data-structures/graph/abstract-graph.ts

@@ -897,7 +897,7 @@ export abstract class AbstractGraph<
     const filtered: [VertexKey, V | undefined][] = [];
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index, this)) {
+      if (predicate.call(thisArg, value, key, index, this)) {
         filtered.push([key, value]);
       }
       index++;
@@ -916,7 +916,7 @@ export abstract class AbstractGraph<
     const filtered: [VertexKey, V | undefined][] = [];
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index, this)) {
+      if (predicate.call(thisArg, value, key, index, this)) {
         filtered.push([key, value]);
       }
       index++;
@@ -928,7 +928,7 @@ export abstract class AbstractGraph<
     const mapped: T[] = [];
     let index = 0;
     for (const [key, value] of this) {
-      mapped.push(callback.call(thisArg, key, value, index, this));
+      mapped.push(callback.call(thisArg, value, key, index, this));
       index++;
     }
     return mapped;

package/src/data-structures/hash/hash-map.ts

@@ -290,7 +290,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: any): any {
     const out = this._createLike<K, VM, [K, VM]>();
     let index = 0;
-    for (const [key, value] of this) out.set(key, callbackfn.call(thisArg, key, value, index++, this));
+    for (const [key, value] of this) out.set(key, callbackfn.call(thisArg, value, key, index++, this));
     return out;
   }
 
@@ -305,7 +305,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): any {
     const out = this._createLike<K, V, [K, V]>();
     let index = 0;
-    for (const [key, value] of this) if (predicate.call(thisArg, key, value, index++, this)) out.set(key, value);
+    for (const [key, value] of this) if (predicate.call(thisArg, value, key, index++, this)) out.set(key, value);
     return out;
   }
 
@@ -677,7 +677,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     const out = this._createLike<K, V, [K, V]>();
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index, this)) out.set(key, value);
+      if (predicate.call(thisArg, value, key, index, this)) out.set(key, value);
       index++;
     }
     return out;
@@ -696,7 +696,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     const out = this._createLike<MK, MV, [MK, MV]>();
     let index = 0;
     for (const [key, value] of this) {
-      const [newKey, newValue] = callback.call(thisArg, key, value, index, this);
+      const [newKey, newValue] = callback.call(thisArg, value, key, index, this);
       out.set(newKey, newValue);
       index++;
     }

package/src/types/data-structures/base/base.ts

@@ -1,7 +1,7 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
 import { LinearBase } from '../../../data-structures/base/linear-base';
 
-export type EntryCallback<K, V, R> = (key: K, value: V, index: number, original: IterableEntryBase<K, V>) => R;
+export type EntryCallback<K, V, R> = (value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
 export type ElementCallback<E, R, RT> = (element: E, index: number, original: IterableElementBase<E, R>) => RT;
 export type ReduceEntryCallback<K, V, R> = (
   accumulator: R,

package/test/performance/data-structures/binary-tree/red-black-tree.test.ts

@@ -2,57 +2,60 @@ import { RedBlackTree } from '../../../../src';
 import * as Benchmark from 'benchmark';
 import { getRandomIntArray, magnitude } from '../../../utils';
 import { OrderedMap } from 'js-sdsl';
-import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
 const rbTree = new RedBlackTree<number>();
-const rbTreeNodeMode = new RedBlackTree<number>([], { isMapMode: false });
+// const rbTreeNodeMode = new RedBlackTree<number>([], { isMapMode: false });
 
-const { HUNDRED_THOUSAND } = magnitude;
-const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
+const { MILLION } = magnitude;
+const randomArray = getRandomIntArray(MILLION, 0, MILLION - 1, true);
 const cOrderedMap = new OrderedMap<number, number>();
 
 suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
-    rbTree.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+  // .add(`${MILLION.toLocaleString()} add randomly`, () => {
+  //   rbTree.clear();
+  //   for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+  // })
+  .add(`${MILLION.toLocaleString()} add`, () => {
     rbTree.clear();
     for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
+  .add(`${MILLION.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
-    for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode add randomly`, () => {
-    rbTreeNodeMode.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.add(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode get`, () => {
-    for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.get(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
+  // .add(`${MILLION.toLocaleString()} getNode`, () => {
+  //   for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
+  // })
+  // .add(`${MILLION.toLocaleString()} node mode add randomly`, () => {
+  //   rbTreeNodeMode.clear();
+  //   for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.add(randomArray[i]);
+  // })
+  // .add(`${MILLION.toLocaleString()} node mode get`, () => {
+  //   for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.get(randomArray[i]);
+  // })
+  .add(`${MILLION.toLocaleString()} iterator`, () => {
     const entries = [...rbTree];
-    return entries.length === HUNDRED_THOUSAND;
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete orderly`, () => {
-    rbTree.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
-    for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
-    rbTree.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
-    for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+    return entries.length === MILLION;
   });
+// .add(`${MILLION.toLocaleString()} add & delete orderly`, () => {
+//   rbTree.clear();
+//   for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
+//   for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
+// })
+// .add(`${MILLION.toLocaleString()} add & delete randomly`, () => {
+//   rbTree.clear();
+//   for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+//   for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+// });
 
-if (isCompetitor) {
-  suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-    for (let i = 0; i < randomArray.length; i++) cOrderedMap.setElement(randomArray[i], randomArray[i]);
-  });
+if (true) {
+  suite
+    .add(`CPT ${MILLION.toLocaleString()} add`, () => {
+      for (let i = 0; i < randomArray.length; i++) cOrderedMap.setElement(randomArray[i], randomArray[i]);
+    })
+    .add(`CPT ${MILLION.toLocaleString()} add`, () => {
+      for (let i = 0; i < randomArray.length; i++) cOrderedMap.getElementByKey(randomArray[i]);
+    });
 }
 
 export { suite };

package/test/performance/runner-config.json

@@ -17,20 +17,20 @@
     "**/experimental/**"
   ],
   "order": [
+    "red-black-tree",
+    "queue",
+    "deque",
     "heap",
     "avl-tree",
-    "red-black-tree",
     "doubly-linked-list",
+    "singly-linked-list",
     "linked-hash-map",
     "hash-map",
     "map-graph",
     "graph",
     "directed-graph",
     "undirected-graph",
-    "queue",
-    "deque",
     "priority-queue",
-    "singly-linked-list",
     "binary-tree-overall",
     "bst",
     "trie",

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

@@ -627,7 +627,7 @@ describe('AVLTreeCounter iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    avlCounter.forEach((key, value) => {
+    avlCounter.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -638,7 +638,7 @@ describe('AVLTreeCounter iterative methods test', () => {
   });
 
   it('filter should return a new avlCounter with filtered elements', () => {
-    const filteredTree = avlCounter.filter(key => key > 1);
+    const filteredTree = avlCounter.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -647,7 +647,7 @@ describe('AVLTreeCounter iterative methods test', () => {
   });
 
   it('map should return a new avlCounter with modified elements', () => {
-    const avlCounterMapped = avlCounter.map((key, value) => [(key * 2).toString(), value]);
+    const avlCounterMapped = avlCounter.map((value, key) => [(key * 2).toString(), value]);
     expect(avlCounterMapped.size).toBe(3);
     expect([...avlCounterMapped]).toEqual([
       ['2', 'a'],

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

@@ -415,7 +415,7 @@ describe('AVLTreeMultiMap iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    avlTmm.forEach((key, value) => {
+    avlTmm.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -426,7 +426,7 @@ describe('AVLTreeMultiMap iterative methods test', () => {
   });
 
   it('filter should return a new avlTmm with filtered elements', () => {
-    const filteredTree = avlTmm.filter(key => key > 1);
+    const filteredTree = avlTmm.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, ['b']],
@@ -435,7 +435,7 @@ describe('AVLTreeMultiMap iterative methods test', () => {
   });
 
   it('map should return a new avlTmm with modified elements', () => {
-    const avlTmmMapped = avlTmm.map((key, value) => [(key * 2).toString(), value ? value : []]);
+    const avlTmmMapped = avlTmm.map((value, key) => [(key * 2).toString(), value ? value : []]);
     expect(avlTmmMapped.size).toBe(3);
     expect([...avlTmmMapped]).toEqual([
       ['2', ['a']],

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

@@ -386,7 +386,7 @@ describe('AVLTree iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    avlTree.forEach((key, value) => {
+    avlTree.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -397,7 +397,7 @@ describe('AVLTree iterative methods test', () => {
   });
 
   it('filter should return a new avlTree with filtered elements', () => {
-    const filteredTree = avlTree.filter(key => key > 1);
+    const filteredTree = avlTree.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -406,7 +406,7 @@ describe('AVLTree iterative methods test', () => {
   });
 
   it('map should return a new avlTree with modified elements', () => {
-    const mappedTree = avlTree.map((key, value) => [(key * 2).toString(), value]);
+    const mappedTree = avlTree.map((value, key) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
       ['2', 'a'],

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

@@ -1308,7 +1308,7 @@ describe('BinaryTree (map mode) - higher-order & iteration', () => {
 
   it('forEach(): iterates all entries', () => {
     const mockCallback = jest.fn();
-    binaryTree.forEach((key, value) => {
+    binaryTree.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -1319,7 +1319,7 @@ describe('BinaryTree (map mode) - higher-order & iteration', () => {
   });
 
   it('filter(): returns new tree with filtered entries', () => {
-    const filteredTree = binaryTree.filter(key => key > 1);
+    const filteredTree = binaryTree.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [3, 'c'],
@@ -1328,7 +1328,7 @@ describe('BinaryTree (map mode) - higher-order & iteration', () => {
   });
 
   it('map(): returns new tree with transformed keys/values', () => {
-    const mappedTree = binaryTree.map((key, value) => [(key * 2).toString(), value]);
+    const mappedTree = binaryTree.map((value, key) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
       ['2', 'a'],
@@ -1578,7 +1578,7 @@ describe('Coverage boosters - close remaining uncovered branches', () => {
       [1, 'a'],
       [2, 'b']
     ]);
-    const mapped = t.map((k, v) => [String(k), (v ?? '').toUpperCase()], { iterationType: 'RECURSIVE' } as any);
+    const mapped = t.map((v, k) => [String(k), (v ?? '').toUpperCase()], { iterationType: 'RECURSIVE' } as any);
     expect(Array.from(mapped)).toEqual([
       ['1', 'A'],
       ['2', 'B']

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

@@ -1109,7 +1109,7 @@ describe('BST iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    bst.forEach((key, value) => {
+    bst.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -1120,7 +1120,7 @@ describe('BST iterative methods test', () => {
   });
 
   it('filter should return a new tree with filtered elements', () => {
-    const filteredTree = bst.filter(key => key > 1);
+    const filteredTree = bst.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -1129,7 +1129,7 @@ describe('BST iterative methods test', () => {
   });
 
   it('map should return a new tree with modified elements', () => {
-    const mappedTree = bst.map((key, value) => [(key * 2).toString(), value]);
+    const mappedTree = bst.map((value, key) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
       ['2', 'a'],

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

@@ -648,7 +648,7 @@ describe('RedBlackTree 2', () => {
 
     it('forEach should iterate over all elements', () => {
       const mockCallback = jest.fn();
-      rbTree.forEach((key, value) => {
+      rbTree.forEach((value, key) => {
         mockCallback(key, value);
       });
 
@@ -659,7 +659,7 @@ describe('RedBlackTree 2', () => {
     });
 
     it('filter should return a new rbTree with filtered elements', () => {
-      const filteredTree = rbTree.filter(key => key > 1);
+      const filteredTree = rbTree.filter((_value, key) => key > 1);
       expect(filteredTree.size).toBe(2);
       expect([...filteredTree]).toEqual([
         [2, 'b'],
@@ -668,7 +668,7 @@ describe('RedBlackTree 2', () => {
     });
 
     it('map should return a new rbTree with modified elements', () => {
-      const rbTreeMapped = rbTree.map((key, value) => [(key * 2).toString(), value]);
+      const rbTreeMapped = rbTree.map((value, key) => [(key * 2).toString(), value]);
       expect(rbTreeMapped.size).toBe(3);
       expect([...rbTreeMapped]).toEqual([
         ['2', 'a'],

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

@@ -765,7 +765,7 @@ describe('TreeCounter iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    treeCounter.forEach((key, value) => {
+    treeCounter.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -776,7 +776,7 @@ describe('TreeCounter iterative methods test', () => {
   });
 
   it('filter should return a new tree with filtered elements', () => {
-    const filteredTree = treeCounter.filter(key => key > 1);
+    const filteredTree = treeCounter.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -785,7 +785,7 @@ describe('TreeCounter iterative methods test', () => {
   });
 
   it('map should return a new tree with modified elements', () => {
-    const treeCounterMapped = treeCounter.map((key, value) => [(key * 2).toString(), value]);
+    const treeCounterMapped = treeCounter.map((value, key) => [(key * 2).toString(), value]);
     expect(treeCounterMapped.size).toBe(3);
     expect([...treeCounterMapped]).toEqual([
       ['2', 'a'],

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

@@ -643,7 +643,7 @@ describe('TreeMultiMap 2', () => {
 
     it('forEach should iterate over all elements', () => {
       const mockCallback = jest.fn();
-      tmm.forEach((key, value) => {
+      tmm.forEach((value, key) => {
         mockCallback(key, value);
       });
 
@@ -654,7 +654,7 @@ describe('TreeMultiMap 2', () => {
     });
 
     it('filter should return a new tmm with filtered elements', () => {
-      const filteredTree = tmm.filter(key => key > 1);
+      const filteredTree = tmm.filter((_value, key) => key > 1);
       expect(filteredTree.size).toBe(2);
       expect([...filteredTree]).toEqual([
         [2, ['b']],
@@ -663,7 +663,7 @@ describe('TreeMultiMap 2', () => {
     });
 
     it('map should return a new tmm with modified elements', () => {
-      const tmmMapped = tmm.map((key, value) => [(key * 2).toString(), value ? value : []]);
+      const tmmMapped = tmm.map((value, key) => [(key * 2).toString(), value ? value : []]);
       expect(tmmMapped.size).toBe(3);
       expect([...tmmMapped]).toEqual([
         ['2', ['a']],

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

@@ -680,12 +680,12 @@ describe('DirectedGraph iterative Methods', () => {
 
   it('forEach should apply a function to each vertex', () => {
     const result: VertexKey[] = [];
-    graph.forEach(key => key && result.push(key));
+    graph.forEach((_value, key) => key && result.push(key));
     expect(result).toEqual(vertexMap);
   });
 
   it('filter should return vertexMap that satisfy the condition', () => {
-    const filtered = graph.filterEntries(key => key === 'A' || key === 'B');
+    const filtered = graph.filterEntries((_value, key) => key === 'A' || key === 'B');
     expect(filtered).toEqual([
       ['A', undefined],
       ['B', undefined]
@@ -693,7 +693,7 @@ describe('DirectedGraph iterative Methods', () => {
   });
 
   it('map should apply a function to each vertex and return a new array', () => {
-    const mapped = graph.map(vertex => vertex + '_mapped');
+    const mapped = graph.map((_value, vertex) => vertex + '_mapped');
     expect(mapped).toEqual(vertexMap.map(key => key + '_mapped'));
   });