graph-typed 1.46.1 → 1.46.3

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

@@ -6,127 +6,8 @@
  * @license MIT License
  */
 
-import { isObjOrFunc, rangeCheck, throwRangeError } from '../../utils';
-import { HashMapLinkedNode, IterableWithSizeOrLength, IterateDirection } from '../../types';
-
-/**
- * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
- * these underlying structures have already dealt with dynamic expansion and hash collisions.
- * Therefore, there is no need for additional logic to handle these issues.
- */
-export class HashMapIterator<K, V> {
-  readonly hashMap: HashMap<K, V>;
-  readonly iterateDirection: IterateDirection;
-  protected _node: HashMapLinkedNode<K, V>;
-  protected readonly _sentinel: HashMapLinkedNode<K, V>;
-
-  /**
-   * This is a constructor function for a linked list iterator in a HashMap data structure.
-   * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
-   * represents a node in a linked list used in a hash map data structure. It contains a key-value pair
-   * and references to the previous and next nodes in the linked list.
-   * @param sentinel - The `sentinel` parameter is a reference to a special node in a linked list. It
-   * is used to mark the beginning or end of the list and is typically used in data structures like
-   * hash maps or linked lists to simplify operations and boundary checks.
-   * @param hashMap - A HashMap object that stores key-value pairs.
-   * @param {IterateDirection} iterateDirection - The `iterateDirection` parameter is an optional
-   * parameter that specifies the direction in which the iterator should iterate over the elements of
-   * the HashMap. It can take one of the following values:
-   * @returns The constructor does not return anything. It is used to initialize the properties and
-   * methods of the object being created.
-   */
-  constructor(
-    node: HashMapLinkedNode<K, V>,
-    sentinel: HashMapLinkedNode<K, V>,
-    hashMap: HashMap<K, V>,
-    iterateDirection: IterateDirection = IterateDirection.DEFAULT
-  ) {
-    this._node = node;
-    this._sentinel = sentinel;
-    this.iterateDirection = iterateDirection;
-
-    if (this.iterateDirection === IterateDirection.DEFAULT) {
-      this.prev = function () {
-        if (this._node.prev === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.prev;
-        return this;
-      };
-      this.next = function () {
-        if (this._node === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.next;
-        return this;
-      };
-    } else {
-      this.prev = function () {
-        if (this._node.next === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.next;
-        return this;
-      };
-      this.next = function () {
-        if (this._node === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.prev;
-        return this;
-      };
-    }
-    this.hashMap = hashMap;
-  }
-
-  /**
-   * The above function returns a Proxy object that allows access to the key and value of a node in a
-   * data structure.
-   * @returns The code is returning a Proxy object.
-   */
-  get current() {
-    if (this._node === this._sentinel) {
-      throwRangeError();
-    }
-
-    return new Proxy(<[K, V]>(<unknown>[]), {
-      get: (target, prop: '0' | '1') => {
-        if (prop === '0') return this._node.key;
-        else if (prop === '1') return this._node.value;
-        target[0] = this._node.key;
-        target[1] = this._node.value;
-        return target[prop];
-      },
-      set: (_, prop: '1', newValue: V) => {
-        if (prop !== '1') {
-          throw new TypeError(`prop should be string '1'`);
-        }
-        this._node.value = newValue;
-        return true;
-      }
-    });
-  }
-
-  /**
-   * The function checks if a node is accessible.
-   * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
-   */
-  isAccessible() {
-    return this._node !== this._sentinel;
-  }
-
-  prev() {
-    return this;
-  }
-
-  next() {
-    return this;
-  }
-
-  clone() {
-    return new HashMapIterator<K, V>(this._node, this._sentinel, this.hashMap, this.iterateDirection)
-  }
-}
+import { isObjOrFunc, rangeCheck } from '../../utils';
+import { HashMapLinkedNode, IterableWithSizeOrLength } from '../../types';
 
 export class HashMap<K = any, V = any> {
   readonly OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
@@ -158,53 +39,6 @@ export class HashMap<K = any, V = any> {
     return this._size;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new iterator object for a HashMap.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get begin() {
-    return new HashMapIterator<K, V>(this._head, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-   * end values.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get end() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-   * a HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseBegin() {
-    return new HashMapIterator<K, V>(this._tail, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-   * HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseEnd() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -231,6 +65,29 @@ export class HashMap<K = any, V = any> {
     return <[K, V]>[this._tail.key, this._tail.value];
   }
 
+  /**
+   * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
+   */
+  * begin() {
+    let node = this._head;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.next;
+    }
+  }
+
+  /**
+   * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+   * key and value.
+   */
+  * reverseBegin() {
+    let node = this._tail;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.prev;
+    }
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -332,34 +189,6 @@ export class HashMap<K = any, V = any> {
     return <[K, V]>[node.key, node.value];
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `getIterator` returns a new instance of `HashMapIterator` based on the provided key
-   * and whether it is an object key or not.
-   * @param {K} key - The `key` parameter is the key used to retrieve the iterator from the HashMap. It
-   * can be of any type, depending on how the HashMap is implemented.
-   * @param {boolean} [isObjectKey] - The `isObjectKey` parameter is an optional boolean parameter that
-   * indicates whether the `key` parameter is an object key. If `isObjectKey` is `true`, it means that
-   * the `key` parameter is an object and needs to be handled differently. If `isObjectKey` is `false`
-   * @returns a new instance of the `HashMapIterator` class.
-   */
-  getIterator(key: K, isObjectKey?: boolean) {
-    let node: HashMapLinkedNode<K, V>;
-    if (isObjectKey) {
-      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      if (index === undefined) {
-        node = this._sentinel;
-      } else {
-        node = this._nodes[index];
-      }
-    } else {
-      node = this._orgMap[<string>(<unknown>key)] || this._sentinel;
-    }
-    return new HashMapIterator<K, V>(node, this._sentinel, this);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)