min-heap-typed 1.52.3 → 1.52.5

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

@@ -34,12 +34,8 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     super();
     if (options) {
       const { hashFn, toEntryFn } = options;
-      if (hashFn) {
-        this._hashFn = hashFn;
-      }
-      if (toEntryFn) {
-        this._toEntryFn = toEntryFn;
-      }
+      if (hashFn) this._hashFn = hashFn;
+      if (toEntryFn) this._toEntryFn = toEntryFn;
     }
     if (entryOrRawElements) {
       this.setMany(entryOrRawElements);
@@ -167,8 +163,8 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
       if (this.isEntry(rawEle)) {
         key = rawEle[0];
         value = rawEle[1];
-      } else if (this.toEntryFn) {
-        const item = this.toEntryFn(rawEle);
+      } else if (this._toEntryFn) {
+        const item = this._toEntryFn(rawEle);
         key = item[0];
         value = item[1];
       }
@@ -238,9 +234,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
-   */
-
-  /**
+   *
    * The clone function creates a new HashMap with the same key-value pairs as
    * this one. The clone function is useful for creating a copy of an existing
    * HashMap, and then modifying that copy without affecting the original.
@@ -248,14 +242,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * @return A new hashmap with the same values as this one
    */
   clone(): HashMap<K, V, R> {
-    return new HashMap<K, V, R>(this, { hashFn: this.hashFn, toEntryFn: this.toEntryFn });
+    return new HashMap<K, V, R>(this, { hashFn: this._hashFn, toEntryFn: this._toEntryFn });
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -306,18 +295,6 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     return filteredMap;
   }
 
-  /**
-   * The put function sets a value in a data structure using a specified key.
-   * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
-   * to the function.
-   * @param {V} value - The value parameter represents the value that you want to associate with the
-   * specified key in the data structure.
-   * @returns The method is returning a boolean value.
-   */
-  put(key: K, value: V): boolean {
-    return this.set(key, value);
-  }
-
   /**
    * The function returns an iterator that yields key-value pairs from both an object store and an
    * object map.
@@ -353,7 +330,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
     let strKey: string;
     if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
-      strKey = this.hashFn(key);
+      strKey = this._hashFn(key);
     } else {
       if (keyType === 'number') {
         // TODO numeric key should has its own hash
@@ -383,7 +360,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    * @param [options] - The `options` parameter is an optional object that can contain the following
    * properties:
    */
-  constructor(entryOrRawElements: Iterable<R> = [], options?: LinkedHashMapOptions<K, V, R>) {
+  constructor(entryOrRawElements: Iterable<R | [K, V]> = [], options?: LinkedHashMapOptions<K, V, R>) {
     super();
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
@@ -399,10 +376,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     }
 
     if (entryOrRawElements) {
-      for (const el of entryOrRawElements) {
-        const [key, value] = this.toEntryFn(el);
-        this.set(key, value);
-      }
+      this.setMany(entryOrRawElements);
     }
   }
 
@@ -469,7 +443,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return this._tail;
   }
 
-  protected _toEntryFn: (rawElement: R) => [K, V] = (rawElement: R) => {
+  protected _toEntryFn?: (rawElement: R) => [K, V] = (rawElement: R) => {
     if (this.isEntry(rawElement)) {
       // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
       return rawElement;
@@ -498,11 +472,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return this._size;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -516,11 +485,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return <[K, V]>[this.head.key, this.head.value];
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -557,11 +521,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     }
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -579,7 +538,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     const isNewKey = !this.has(key); // Check if the key is new
 
     if (isWeakKey(key)) {
-      const hash = this.objHashFn(key);
+      const hash = this._objHashFn(key);
       node = this.objMap.get(hash);
 
       if (!node && isNewKey) {
@@ -591,7 +550,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
         node.value = value;
       }
     } else {
-      const hash = this.hashFn(key);
+      const hash = this._hashFn(key);
       node = this.noObjMap[hash];
 
       if (!node && isNewKey) {
@@ -627,11 +586,20 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    * R.
    * @returns The `setMany` function returns an array of booleans.
    */
-  setMany(entryOrRawElements: Iterable<R>): boolean[] {
+  setMany(entryOrRawElements: Iterable<R | [K, V]>): boolean[] {
     const results: boolean[] = [];
     for (const rawEle of entryOrRawElements) {
-      const [key, value] = this.toEntryFn(rawEle);
-      results.push(this.set(key, value));
+      let key: K | undefined, value: V | undefined;
+      if (this.isEntry(rawEle)) {
+        key = rawEle[0];
+        value = rawEle[1];
+      } else if (this._toEntryFn) {
+        const item = this._toEntryFn(rawEle);
+        key = item[0];
+        value = item[1];
+      }
+
+      if (key !== undefined && value !== undefined) results.push(this.set(key, value));
     }
     return results;
   }
@@ -644,19 +612,14 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    */
   override has(key: K): boolean {
     if (isWeakKey(key)) {
-      const hash = this.objHashFn(key);
+      const hash = this._objHashFn(key);
       return this.objMap.has(hash);
     } else {
-      const hash = this.hashFn(key);
+      const hash = this._hashFn(key);
       return hash in this.noObjMap;
     }
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -672,21 +635,16 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    */
   override get(key: K): V | undefined {
     if (isWeakKey(key)) {
-      const hash = this.objHashFn(key);
+      const hash = this._objHashFn(key);
       const node = this.objMap.get(hash);
       return node ? node.value : undefined;
     } else {
-      const hash = this.hashFn(key);
+      const hash = this._hashFn(key);
       const node = this.noObjMap[hash];
       return node ? node.value : undefined;
     }
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -707,11 +665,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return node.value;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -726,7 +679,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     let node;
 
     if (isWeakKey(key)) {
-      const hash = this.objHashFn(key);
+      const hash = this._objHashFn(key);
       // Get nodes from WeakMap
       node = this.objMap.get(hash);
 
@@ -737,7 +690,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
       // Remove nodes from WeakMap
       this.objMap.delete(hash);
     } else {
-      const hash = this.hashFn(key);
+      const hash = this._hashFn(key);
       // Get nodes from noObjMap
       node = this.noObjMap[hash];
 
@@ -754,11 +707,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return true;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -777,11 +725,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return this._deleteNode(node);
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -804,11 +747,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return Array.isArray(rawElement) && rawElement.length === 2;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -821,11 +759,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -836,7 +769,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    * of the original `LinkedHashMap` object.
    */
   clone(): LinkedHashMap<K, V> {
-    const cloned = new LinkedHashMap<K, V>([], { hashFn: this.hashFn, objHashFn: this.objHashFn });
+    const cloned = new LinkedHashMap<K, V>([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
     for (const entry of this) {
       const [key, value] = entry;
       cloned.set(key, value);
@@ -844,11 +777,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return cloned;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -876,11 +804,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return filteredMap;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -909,32 +832,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return mappedMap;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The put function sets a value in a data structure using a specified key.
-   * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
-   * to the function.
-   * @param {V} value - The value parameter represents the value that you want to associate with the
-   * specified key in the data structure.
-   * @returns The method is returning a boolean value.
-   */
-  put(key: K, value: V): boolean {
-    return this.set(key, value);
-  }
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   * where n is the number of entries in the LinkedHashMap.
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -950,11 +847,6 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     }
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

package/src/data-structures/heap/heap.ts

@@ -560,11 +560,6 @@ export class FibonacciHeap<E> {
     return this.min ? this.min.element : undefined;
   }
 
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
@@ -612,11 +607,6 @@ export class FibonacciHeap<E> {
     }
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -628,11 +618,6 @@ export class FibonacciHeap<E> {
     return this.pop();
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -667,11 +652,6 @@ export class FibonacciHeap<E> {
     return z.element;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -732,11 +712,6 @@ export class FibonacciHeap<E> {
     return 0;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -755,11 +730,6 @@ export class FibonacciHeap<E> {
     }
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -774,11 +744,6 @@ export class FibonacciHeap<E> {
     if (node.right) node.right.left = node.left;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -797,11 +762,6 @@ export class FibonacciHeap<E> {
     y.parent = x;
   }
 
-  /**
-   * Time Complexity: O(n log n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n log n)
    * Space Complexity: O(n)