max-heap-typed 2.2.0 → 2.2.2

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "max-heap-typed",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Max Heap",
   "browser": "dist/umd/max-heap-typed.min.js",
   "umd:main": "dist/umd/max-heap-typed.min.js",
@@ -170,6 +170,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^2.2.0"
+    "data-structure-typed": "^2.2.2"
   }
 }

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,