heap-typed 1.47.1 → 1.47.3

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": "heap-typed",
-  "version": "1.47.1",
+  "version": "1.47.3",
   "description": "Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.47.1"
+    "data-structure-typed": "^1.47.3"
   }
 }

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) {