binary-tree-typed 2.2.0 → 2.2.1

package/dist/types/data-structures/binary-tree/avl-tree.d.ts

@@ -125,7 +125,9 @@ export declare 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 };

package/dist/types/data-structures/binary-tree/binary-tree.d.ts

@@ -123,6 +123,7 @@ export declare 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

package/dist/types/data-structures/binary-tree/bst.d.ts

@@ -124,6 +124,7 @@ export declare 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>([

package/dist/types/data-structures/binary-tree/red-black-tree.d.ts

@@ -110,6 +110,7 @@ export declare 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

package/dist/types/data-structures/binary-tree/tree-multi-map.d.ts

@@ -113,6 +113,7 @@ export declare class TreeMultiMapNode<K = any, V = any> {
  * @template K
  * @template V
  * @template R
+ *
  * @example
  * // players ranked by score with their equipment
  *     type Equipment = {

package/dist/types/types/data-structures/base/base.d.ts

@@ -1,6 +1,6 @@
 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, value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
 export type ReduceElementCallback<E, R, U = E> = (accumulator: U, value: E, index: number, self: IterableElementBase<E, R>) => U;

package/dist/umd/binary-tree-typed.js

@@ -907,7 +907,7 @@ var binaryTreeTyped = (() => {
     every(predicate, thisArg) {
       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;
         }
       }
@@ -923,7 +923,7 @@ var binaryTreeTyped = (() => {
     some(predicate, thisArg) {
       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;
         }
       }
@@ -939,7 +939,7 @@ var binaryTreeTyped = (() => {
       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);
       }
     }
     /**
@@ -953,7 +953,7 @@ var binaryTreeTyped = (() => {
       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;
     }
@@ -2204,7 +2204,7 @@ var binaryTreeTyped = (() => {
     filter(predicate, thisArg) {
       const out = this._createInstance();
       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;
     }
     /**
@@ -2222,7 +2222,7 @@ var binaryTreeTyped = (() => {
     map(cb, options, thisArg) {
       const out = this._createLike([], 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;
     }
     /**