priority-queue-typed 1.46.9 → 1.47.2

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

@@ -430,10 +430,42 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * by the return type of the `callback` function.
      */
     morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined): ReturnType<C>[];
-    forEach(callback: (entry: [BTNKey, V | undefined], tree: typeof this) => void): void;
-    filter(predicate: (entry: [BTNKey, V | undefined], tree: typeof this) => boolean): TREE;
-    map(callback: (entry: [BTNKey, V | undefined], tree: typeof this) => V): TREE;
-    reduce<T>(callback: (accumulator: T, entry: [BTNKey, V | undefined], tree: typeof this) => T, initialValue: T): T;
+    /**
+     * The `forEach` function iterates over each entry in a tree and calls a callback function with the
+     * entry and the tree as arguments.
+     * @param callback - The callback parameter is a function that will be called for each entry in the
+     * tree. It takes two parameters: entry and tree.
+     */
+    forEach(callback: (entry: [BTNKey, V | undefined], tree: this) => void): void;
+    /**
+     * The `filter` function creates a new tree by iterating over the entries of the current tree and
+     * adding the entries that satisfy the given predicate.
+     * @param predicate - The `predicate` parameter is a function that takes two arguments: `entry` and
+     * `tree`.
+     * @returns The `filter` method is returning a new tree object that contains only the entries that
+     * satisfy the given predicate function.
+     */
+    filter(predicate: (entry: [BTNKey, V | undefined], tree: this) => boolean): TREE;
+    /**
+     * The `map` function creates a new tree by applying a callback function to each entry in the current
+     * tree.
+     * @param callback - The callback parameter is a function that takes two arguments: entry and tree.
+     * @returns The `map` method is returning a new tree object.
+     */
+    map(callback: (entry: [BTNKey, V | undefined], tree: this) => V): TREE;
+    /**
+     * The `reduce` function iterates over the entries of a tree and applies a callback function to each
+     * entry, accumulating a single value.
+     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+     * entry, and tree. It is called for each entry in the tree and is used to accumulate a single value
+     * based on the logic defined in the callback function.
+     * @param {T} initialValue - The initialValue parameter is the initial value of the accumulator. It
+     * is the value that will be passed as the first argument to the callback function when reducing the
+     * elements of the tree.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+     * all the entries in the tree and applying the callback function to each entry.
+     */
+    reduce<T>(callback: (accumulator: T, entry: [BTNKey, V | undefined], tree: this) => T, initialValue: T): T;
     /**
      * The above function is an iterator for a binary tree that can be used to traverse the tree in
      * either an iterative or recursive manner.

package/dist/data-structures/binary-tree/binary-tree.js

@@ -1411,11 +1411,25 @@ class BinaryTree {
         }
         return ans;
     }
+    /**
+     * The `forEach` function iterates over each entry in a tree and calls a callback function with the
+     * entry and the tree as arguments.
+     * @param callback - The callback parameter is a function that will be called for each entry in the
+     * tree. It takes two parameters: entry and tree.
+     */
     forEach(callback) {
         for (const entry of this) {
             callback(entry, this);
         }
     }
+    /**
+     * The `filter` function creates a new tree by iterating over the entries of the current tree and
+     * adding the entries that satisfy the given predicate.
+     * @param predicate - The `predicate` parameter is a function that takes two arguments: `entry` and
+     * `tree`.
+     * @returns The `filter` method is returning a new tree object that contains only the entries that
+     * satisfy the given predicate function.
+     */
     filter(predicate) {
         const newTree = this.createTree();
         for (const [key, value] of this) {
@@ -1426,13 +1440,19 @@ class BinaryTree {
         return newTree;
     }
     // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: typeof this) => NV) {
+    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
     //   const newTree = this.createTree();
     //   for (const [key, value] of this) {
     //     newTree.add(key, callback([key, value], this));
     //   }
     //   return newTree;
     // }
+    /**
+     * The `map` function creates a new tree by applying a callback function to each entry in the current
+     * tree.
+     * @param callback - The callback parameter is a function that takes two arguments: entry and tree.
+     * @returns The `map` method is returning a new tree object.
+     */
     map(callback) {
         const newTree = this.createTree();
         for (const [key, value] of this) {
@@ -1440,6 +1460,18 @@ class BinaryTree {
         }
         return newTree;
     }
+    /**
+     * The `reduce` function iterates over the entries of a tree and applies a callback function to each
+     * entry, accumulating a single value.
+     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+     * entry, and tree. It is called for each entry in the tree and is used to accumulate a single value
+     * based on the logic defined in the callback function.
+     * @param {T} initialValue - The initialValue parameter is the initial value of the accumulator. It
+     * is the value that will be passed as the first argument to the callback function when reducing the
+     * elements of the tree.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+     * all the entries in the tree and applying the callback function to each entry.
+     */
     reduce(callback, initialValue) {
         let accumulator = initialValue;
         for (const [key, value] of this) {

package/dist/data-structures/hash/hash-map.d.ts

@@ -135,8 +135,35 @@ export declare class HashMap<K = any, V = any> {
      * HashMap. It takes three arguments:
      */
     forEach(callback: (element: [K, V], index: number, hashMap: HashMap<K, V>) => void): void;
+    /**
+     * The `filter` function takes a predicate function and returns a new HashMap containing only the
+     * key-value pairs that satisfy the predicate.
+     * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
+     * `map`.
+     * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
+     * satisfy the given predicate function.
+     */
     filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V>;
+    /**
+     * The `map` function takes a callback function and returns a new HashMap with the values transformed
+     * by the callback.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
+     * `map`.
+     * @returns a new HashMap object with the values mapped according to the provided callback function.
+     */
     map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV>;
+    /**
+     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
+     * each element, accumulating a single value.
+     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+     * element, and map. It is called for each element in the HashMap and is used to accumulate a single
+     * result.
+     * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
+     * is the value that will be passed as the first argument to the `callback` function when reducing
+     * the elements of the map.
+     * @returns The `reduce` function is returning the final value of the accumulator after iterating
+     * over all the elements in the HashMap and applying the callback function to each element.
+     */
     reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A;
     /**
      * Time Complexity: O(n), where n is the number of elements in the HashMap.

package/dist/data-structures/hash/hash-map.js

@@ -277,6 +277,14 @@ class HashMap {
             node = node.next;
         }
     }
+    /**
+     * The `filter` function takes a predicate function and returns a new HashMap containing only the
+     * key-value pairs that satisfy the predicate.
+     * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
+     * `map`.
+     * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
+     * satisfy the given predicate function.
+     */
     filter(predicate) {
         const filteredMap = new HashMap();
         for (const [key, value] of this) {
@@ -286,6 +294,13 @@ class HashMap {
         }
         return filteredMap;
     }
+    /**
+     * The `map` function takes a callback function and returns a new HashMap with the values transformed
+     * by the callback.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
+     * `map`.
+     * @returns a new HashMap object with the values mapped according to the provided callback function.
+     */
     map(callback) {
         const mappedMap = new HashMap();
         for (const [key, value] of this) {
@@ -294,6 +309,18 @@ class HashMap {
         }
         return mappedMap;
     }
+    /**
+     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
+     * each element, accumulating a single value.
+     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+     * element, and map. It is called for each element in the HashMap and is used to accumulate a single
+     * result.
+     * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
+     * is the value that will be passed as the first argument to the `callback` function when reducing
+     * the elements of the map.
+     * @returns The `reduce` function is returning the final value of the accumulator after iterating
+     * over all the elements in the HashMap and applying the callback function to each element.
+     */
     reduce(callback, initialValue) {
         let accumulator = initialValue;
         for (const element of this) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "priority-queue-typed",
-  "version": "1.46.9",
+  "version": "1.47.2",
   "description": "Priority Queue, Min Priority Queue, Max Priority Queue. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -120,6 +120,6 @@
     "typedoc": "^0.25.1"
   },
   "dependencies": {
-    "data-structure-typed": "^1.46.9"
+    "data-structure-typed": "^1.47.2"
   }
 }

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

@@ -53,7 +53,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     return new AVLTreeNode<V, N>(key, value) as N;
   }
 
-  override createTree(options?: AVLTreeOptions) {
+  override createTree(options?: AVLTreeOptions): TREE {
     return new AVLTree<V, N, TREE>({ ...this.options, ...options }) as TREE;
   }
 

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

@@ -1700,13 +1700,27 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return ans;
   }
 
-  forEach(callback: (entry: [BTNKey, V | undefined], tree: typeof this) => void): void {
+  /**
+   * The `forEach` function iterates over each entry in a tree and calls a callback function with the
+   * entry and the tree as arguments.
+   * @param callback - The callback parameter is a function that will be called for each entry in the
+   * tree. It takes two parameters: entry and tree.
+   */
+  forEach(callback: (entry: [BTNKey, V | undefined], tree: this) => void): void {
     for (const entry of this) {
       callback(entry, this);
     }
   }
 
-  filter(predicate: (entry: [BTNKey, V | undefined], tree: typeof this) => boolean) {
+  /**
+   * The `filter` function creates a new tree by iterating over the entries of the current tree and
+   * adding the entries that satisfy the given predicate.
+   * @param predicate - The `predicate` parameter is a function that takes two arguments: `entry` and
+   * `tree`.
+   * @returns The `filter` method is returning a new tree object that contains only the entries that
+   * satisfy the given predicate function.
+   */
+  filter(predicate: (entry: [BTNKey, V | undefined], tree: this) => boolean) {
     const newTree = this.createTree();
     for (const [key, value] of this) {
       if (predicate([key, value], this)) {
@@ -1717,7 +1731,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   }
 
   // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-  // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: typeof this) => NV) {
+  // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
   //   const newTree = this.createTree();
   //   for (const [key, value] of this) {
   //     newTree.add(key, callback([key, value], this));
@@ -1725,7 +1739,13 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   //   return newTree;
   // }
 
-  map(callback: (entry: [BTNKey, V | undefined], tree: typeof this) => V) {
+  /**
+   * The `map` function creates a new tree by applying a callback function to each entry in the current
+   * tree.
+   * @param callback - The callback parameter is a function that takes two arguments: entry and tree.
+   * @returns The `map` method is returning a new tree object.
+   */
+  map(callback: (entry: [BTNKey, V | undefined], tree: this) => V) {
     const newTree = this.createTree();
     for (const [key, value] of this) {
       newTree.add(key, callback([key, value], this));
@@ -1733,7 +1753,19 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return newTree;
   }
 
-  reduce<T>(callback: (accumulator: T, entry: [BTNKey, V | undefined], tree: typeof this) => T, initialValue: T): T {
+  /**
+   * The `reduce` function iterates over the entries of a tree and applies a callback function to each
+   * entry, accumulating a single value.
+   * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+   * entry, and tree. It is called for each entry in the tree and is used to accumulate a single value
+   * based on the logic defined in the callback function.
+   * @param {T} initialValue - The initialValue parameter is the initial value of the accumulator. It
+   * is the value that will be passed as the first argument to the callback function when reducing the
+   * elements of the tree.
+   * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+   * all the entries in the tree and applying the callback function to each entry.
+   */
+  reduce<T>(callback: (accumulator: T, entry: [BTNKey, V | undefined], tree: this) => T, initialValue: T): T {
     let accumulator = initialValue;
     for (const [key, value] of this) {
       accumulator = callback(accumulator, [key, value], this);

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

@@ -305,6 +305,14 @@ export class HashMap<K = any, V = any> {
     }
   }
 
+  /**
+   * The `filter` function takes a predicate function and returns a new HashMap containing only the
+   * key-value pairs that satisfy the predicate.
+   * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
+   * `map`.
+   * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
+   * satisfy the given predicate function.
+   */
   filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V> {
     const filteredMap = new HashMap<K, V>();
     for (const [key, value] of this) {
@@ -315,6 +323,13 @@ export class HashMap<K = any, V = any> {
     return filteredMap;
   }
 
+  /**
+   * The `map` function takes a callback function and returns a new HashMap with the values transformed
+   * by the callback.
+   * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
+   * `map`.
+   * @returns a new HashMap object with the values mapped according to the provided callback function.
+   */
   map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV> {
     const mappedMap = new HashMap<K, NV>();
     for (const [key, value] of this) {
@@ -324,6 +339,18 @@ export class HashMap<K = any, V = any> {
     return mappedMap;
   }
 
+  /**
+   * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
+   * each element, accumulating a single value.
+   * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+   * element, and map. It is called for each element in the HashMap and is used to accumulate a single
+   * result.
+   * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
+   * is the value that will be passed as the first argument to the `callback` function when reducing
+   * the elements of the map.
+   * @returns The `reduce` function is returning the final value of the accumulator after iterating
+   * over all the elements in the HashMap and applying the callback function to each element.
+   */
   reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A {
     let accumulator = initialValue;
     for (const element of this) {