data-structure-typed 1.46.2 → 1.46.4

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

@@ -5,99 +5,23 @@
  * @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, HashMapOptions } from '../../types';
 export declare class HashMap<K = any, V = any> {
-    readonly OBJ_KEY_INDEX: symbol;
-    protected _nodes: HashMapLinkedNode<K, V>[];
-    protected _orgMap: Record<string, HashMapLinkedNode<K, V>>;
-    protected _head: HashMapLinkedNode<K, V>;
-    protected _tail: HashMapLinkedNode<K, V>;
-    protected readonly _sentinel: HashMapLinkedNode<K, V>;
-    /**
-     * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
-     * @param {Iterable<[K, V]>} elements - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
-     * V]>`. It is an array of key-value pairs, where each pair is represented as an array `[K, V]`. The
-     * `K` represents the type of the key and `V` represents the
-     */
-    constructor(elements?: IterableWithSizeOrLength<[K, V]>);
+    protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
+    protected _objMap: WeakMap<WeakKey, HashMapLinkedNode<K, V | undefined>>;
+    protected _head: HashMapLinkedNode<K, V | undefined>;
+    protected _tail: HashMapLinkedNode<K, V | undefined>;
+    protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
+    protected _hashFn: (key: K) => string;
+    protected _objHashFn: (key: K) => WeakKey;
+    /**
+     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
+     * @param options - The `options` parameter is an object that contains the `elements` property. The
+     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
+     */
+    constructor(options?: HashMapOptions<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 | undefined)[], void, unknown>;
+    /**
+     * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+     * key and value.
+     */
+    reverseBegin(): Generator<(K | V | undefined)[], void, unknown>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -126,10 +59,9 @@ export declare class HashMap<K = any, V = any> {
      * type, but typically it is a string or symbol.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
      * value associated with the key being set in the data structure.
-     * @param {boolean} isObjectKey - A boolean flag indicating whether the key is an object key or not.
      * @returns the size of the data structure after the key-value pair has been set.
      */
-    set(key: K, value?: V, isObjectKey?: boolean): number;
+    set(key: K, value?: V): number;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -138,15 +70,12 @@ export declare class HashMap<K = any, V = any> {
      * key directly or by using an index stored in the key object.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
      * of any type, but typically it is a string or symbol.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that
-     * `key` is an object key. If `isObjectKey` is `false`, it means that `key`
      * @returns The value associated with the given key is being returned. If the key is an object key,
      * the value is retrieved from the `_nodes` array using the index stored in the `OBJ_KEY_INDEX`
-     * property of the key. If the key is a string key, the value is retrieved from the `_orgMap` object
+     * property of the key. If the key is a string key, the value is retrieved from the `_noObjMap` object
      * using the key itself. If the key is not found, `undefined` is
      */
-    get(key: K, isObjectKey?: boolean): V | undefined;
+    get(key: K): V | undefined;
     /**
      * Time Complexity: O(n), where n is the index.
      * Space Complexity: O(1)
@@ -159,20 +88,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)
@@ -180,13 +95,10 @@ export declare class HashMap<K = any, V = any> {
      * The `delete` function removes a key-value pair from a map-like data structure.
      * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
      * It can be of any type, but typically it is a string or an object.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that the
-     * `key` parameter is an object key. If `isObjectKey` is `false`, it means that the
      * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
      * was not found.
      */
-    delete(key: K, isObjectKey?: boolean): boolean;
+    delete(key: K): boolean;
     /**
      * Time Complexity: O(n), where n is the index.
      * Space Complexity: O(1)
@@ -223,6 +135,9 @@ 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;
+    filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V>;
+    map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV>;
+    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.
      * Space Complexity: O(1)
@@ -240,5 +155,5 @@ export declare class HashMap<K = any, V = any> {
      * represents a node in a linked list. It contains a key-value pair and references to the previous
      * and next nodes in the list.
      */
-    protected _deleteNode(node: HashMapLinkedNode<K, V>): void;
+    protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): void;
 }