stack-typed 1.46.1 → 1.46.3

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

@@ -5,48 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-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 declare 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);
-    /**
-     * 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(): [K, V];
-    /**
-     * The function checks if a node is accessible.
-     * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
-     */
-    isAccessible(): boolean;
-    prev(): this;
-    next(): this;
-    clone(): HashMapIterator<K, V>;
-}
+import { HashMapLinkedNode, IterableWithSizeOrLength } from '../../types';
 export declare class HashMap<K = any, V = any> {
     readonly OBJ_KEY_INDEX: symbol;
     protected _nodes: HashMapLinkedNode<K, V>[];
@@ -63,41 +22,6 @@ export declare class HashMap<K = any, V = any> {
     constructor(elements?: IterableWithSizeOrLength<[K, V]>);
     protected _size: number;
     get size(): number;
-    /**
-     * 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(): HashMapIterator<K, V>;
-    /**
-     * 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(): HashMapIterator<K, V>;
-    /**
-     * 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(): HashMapIterator<K, V>;
-    /**
-     * 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(): HashMapIterator<K, V>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -116,6 +40,15 @@ export declare class HashMap<K = any, V = any> {
      * data structure.
      */
     get last(): [K, V] | undefined;
+    /**
+     * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
+     */
+    begin(): Generator<(K | V)[], void, unknown>;
+    /**
+     * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+     * key and value.
+     */
+    reverseBegin(): Generator<(K | V)[], void, unknown>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -159,20 +92,6 @@ export declare class HashMap<K = any, V = any> {
      * where `K` is the key and `V` is the value.
      */
     getAt(index: number): [K, V];
-    /**
-     * 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): HashMapIterator<K, V>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -7,113 +7,8 @@
  * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashMap = exports.HashMapIterator = void 0;
+exports.HashMap = void 0;
 const utils_1 = require("../../utils");
-/**
- * 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.
- */
-class HashMapIterator {
-    /**
-     * 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, sentinel, hashMap, iterateDirection = 0 /* IterateDirection.DEFAULT */) {
-        this._node = node;
-        this._sentinel = sentinel;
-        this.iterateDirection = iterateDirection;
-        if (this.iterateDirection === 0 /* IterateDirection.DEFAULT */) {
-            this.prev = function () {
-                if (this._node.prev === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.prev;
-                return this;
-            };
-            this.next = function () {
-                if (this._node === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.next;
-                return this;
-            };
-        }
-        else {
-            this.prev = function () {
-                if (this._node.next === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.next;
-                return this;
-            };
-            this.next = function () {
-                if (this._node === this._sentinel) {
-                    (0, utils_1.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) {
-            (0, utils_1.throwRangeError)();
-        }
-        return new Proxy([], {
-            get: (target, prop) => {
-                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, newValue) => {
-                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(this._node, this._sentinel, this.hashMap, this.iterateDirection);
-    }
-}
-exports.HashMapIterator = HashMapIterator;
 class HashMap {
     /**
      * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
@@ -136,49 +31,6 @@ class HashMap {
     get size() {
         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(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(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(this._tail, this._sentinel, this, 1 /* 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(this._sentinel, this._sentinel, this, 1 /* IterateDirection.REVERSE */);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -205,6 +57,27 @@ class HashMap {
             return;
         return [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)
@@ -305,35 +178,6 @@ class HashMap {
         }
         return [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, isObjectKey) {
-        let node;
-        if (isObjectKey) {
-            const index = key[this.OBJ_KEY_INDEX];
-            if (index === undefined) {
-                node = this._sentinel;
-            }
-            else {
-                node = this._nodes[index];
-            }
-        }
-        else {
-            node = this._orgMap[key] || this._sentinel;
-        }
-        return new HashMapIterator(node, this._sentinel, this);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)