min-heap-typed 1.50.1 → 1.50.3

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

@@ -14,10 +14,6 @@ import { IterableEntryBase } from '../base';
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
-    protected _store: {
-        [key: string]: HashMapStoreItem<K, V>;
-    };
-    protected _objMap: Map<object, V>;
     /**
      * The constructor function initializes a HashMap object with an optional initial collection and
      * options.
@@ -25,13 +21,61 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * `T`. It is an optional parameter and its default value is an empty array `[]`.
      * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(rawCollection?: Iterable<R>, options?: HashMapOptions<K, V, R>);
+    constructor(rawCollection?: Iterable<R | [K, V]>, options?: HashMapOptions<K, V, R>);
+    protected _store: {
+        [key: string]: HashMapStoreItem<K, V>;
+    };
+    /**
+     * The function returns the store object, which is a dictionary of HashMapStoreItem objects.
+     * @returns The store property is being returned. It is a dictionary-like object with string keys and
+     * values of type HashMapStoreItem<K, V>.
+     */
+    get store(): {
+        [p: string]: HashMapStoreItem<K, V>;
+    };
+    protected _objMap: Map<object, V>;
+    /**
+     * The function returns the object map.
+     * @returns The `objMap` property is being returned, which is a `Map` object with keys of type
+     * `object` and values of type `V`.
+     */
+    get objMap(): Map<object, V>;
     protected _toEntryFn: (rawElement: R) => [K, V];
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
     get toEntryFn(): (rawElement: R) => [K, V];
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size(): number;
+    protected _hashFn: (key: K) => string;
+    /**
+     * The hasFn function is a function that takes in an item and returns a boolean
+     * indicating whether the item is contained within the hash table.
+     *
+     * @return The hash function
+     */
+    get hashFn(): (key: K) => string;
+    /**
+     * The function checks if a given element is an array with exactly two elements.
+     * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
+     * data type.
+     * @returns a boolean value.
+     */
     isEntry(rawElement: any): rawElement is [K, V];
+    /**
+     * The function checks if the size of an object is equal to zero and returns a boolean value.
+     * @returns A boolean value indicating whether the size of the object is 0 or not.
+     */
     isEmpty(): boolean;
+    /**
+     * The clear() function resets the state of an object by clearing its internal store, object map, and
+     * size.
+     */
     clear(): void;
     /**
      * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
@@ -50,7 +94,7 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * `T`.
      * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(rawCollection: Iterable<R>): boolean[];
+    setMany(rawCollection: Iterable<R | [K, V]>): boolean[];
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
@@ -75,6 +119,18 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * successfully deleted from the map, and `false` if the key was not found in the map.
      */
     delete(key: K): boolean;
+    /**
+     * 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.
+     *
+     * @return A new hashmap with the same values as this one
+     */
+    clone(): HashMap<K, V, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -94,10 +150,6 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * the provided callback function.
      */
     map<U>(callbackfn: EntryCallback<K, V, U>, thisArg?: any): HashMap<K, U>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -115,14 +167,33 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * from the original `HashMap` that pass the provided `predicate` function.
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): HashMap<K, V>;
+    /**
+     * 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;
     /**
      * The function returns an iterator that yields key-value pairs from both an object store and an
      * object map.
      */
     protected _getIterator(): IterableIterator<[K, V]>;
-    protected _hashFn: (key: K) => string;
+    /**
+     * The function checks if a given key is an object or a function.
+     * @param {any} key - The parameter "key" can be of any type.
+     * @returns a boolean value.
+     */
     protected _isObjKey(key: any): key is object | ((...args: any[]) => any);
+    /**
+     * The function `_getNoObjKey` takes a key and returns a string representation of the key, handling
+     * different types of keys.
+     * @param {K} key - The `key` parameter is of type `K`, which represents the type of the key being
+     * passed to the `_getNoObjKey` function.
+     * @returns a string value.
+     */
     protected _getNoObjKey(key: K): string;
 }
 /**
@@ -130,15 +201,73 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
  * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of entries through the linked list.
  * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
  */
-export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
+export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
+    protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
+    /**
+     * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements. It is
+     * used to initialize the HashMapLinked instance with key-value pairs. Each element in the
+     * `rawCollection` is converted to a key-value pair using the `toEntryFn` function (if provided) and
+     * then added to the HashMap
+     * @param [options] - The `options` parameter is an optional object that can contain the following
+     * properties:
+     */
+    constructor(rawCollection?: Iterable<R>, options?: LinkedHashMapOptions<K, V, R>);
+    protected _hashFn: (key: K) => string;
+    /**
+     * The function returns the hash function used for generating a hash value for a given key.
+     * @returns The hash function that takes a key of type K and returns a string.
+     */
+    get hashFn(): (key: K) => string;
+    protected _objHashFn: (key: K) => object;
+    /**
+     * The function returns the object hash function.
+     * @returns The function `objHashFn` is being returned.
+     */
+    get objHashFn(): (key: K) => object;
     protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
+    /**
+     * The function returns a record of HashMapLinkedNode objects with string keys.
+     * @returns The method is returning a Record object, which is a TypeScript type that represents an
+     * object with string keys and values that are HashMapLinkedNode objects with keys of type K and
+     * values of type V or undefined.
+     */
+    get noObjMap(): Record<string, HashMapLinkedNode<K, V | undefined>>;
     protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
+    /**
+     * The function returns the WeakMap object used to map objects to HashMapLinkedNode instances.
+     * @returns The `objMap` property is being returned.
+     */
+    get objMap(): WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
     protected _head: HashMapLinkedNode<K, V | undefined>;
+    /**
+     * The function returns the head node of a HashMapLinkedNode.
+     * @returns The method `getHead()` is returning a `HashMapLinkedNode` object with key type `K` and
+     * value type `V | undefined`.
+     */
+    get head(): HashMapLinkedNode<K, V | undefined>;
     protected _tail: HashMapLinkedNode<K, V | undefined>;
-    protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
-    constructor(entries?: Iterable<[K, V]>, options?: LinkedHashMapOptions<K>);
+    /**
+     * The function returns the tail node of a HashMapLinkedNode.
+     * @returns The `_tail` property of type `HashMapLinkedNode<K, V | undefined>` is being returned.
+     */
+    get tail(): HashMapLinkedNode<K, V | undefined>;
+    protected _toEntryFn: (rawElement: R) => [K, V];
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
+    get toEntryFn(): (rawElement: R) => [K, V];
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object.
+     */
     get size(): number;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -148,6 +277,10 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * value (V).
      */
     get first(): [K, V] | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -166,6 +299,10 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * key and value.
      */
     reverseBegin(): Generator<(K | V | undefined)[], void, unknown>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -179,8 +316,26 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * @returns the size of the data structure after the key-value pair has been set.
      */
     set(key: K, value?: V): boolean;
+    /**
+     * The function `setMany` takes an iterable collection, converts each element into a key-value pair
+     * using a provided function, and sets each key-value pair in the current object, returning an array
+     * of booleans indicating the success of each set operation.
+     * @param rawCollection - The rawCollection parameter is an iterable collection of elements of type
+     * R.
+     * @returns The `setMany` function returns an array of booleans.
+     */
+    setMany(rawCollection: Iterable<R>): boolean[];
+    /**
+     * The function checks if a given key exists in a map, using different logic depending on whether the
+     * key is a weak key or not.
+     * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
+     * @returns The method `has` is returning a boolean value.
+     */
     has(key: K): boolean;
-    setMany(entries: Iterable<[K, V]>): boolean[];
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -196,18 +351,28 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     get(key: K): V | undefined;
     /**
-     * Time Complexity: O(n), where n is the index.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function `getAt` retrieves the key-value pair at a specified index in a linked list.
+     * The function `at` retrieves the key-value pair at a specified index in a linked list.
      * @param {number} index - The index parameter is a number that represents the position of the
      * element we want to retrieve from the data structure.
-     * @returns The method `getAt(index: number)` is returning an array containing the key-value pair at
+     * @returns The method `at(index: number)` is returning an array containing the key-value pair at
      * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
      * where `K` is the key and `V` is the value.
      */
-    getAt(index: number): V | undefined;
+    at(index: number): V | undefined;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -219,7 +384,12 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     delete(key: K): boolean;
     /**
-     * Time Complexity: O(n), where n is the index.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `deleteAt` function deletes a node at a specified index in a linked list.
@@ -229,6 +399,11 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     deleteAt(index: number): boolean;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -238,14 +413,44 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     isEmpty(): boolean;
     /**
+     * The function checks if a given element is an array with exactly two elements.
+     * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
+     * data type.
+     * @returns a boolean value.
+     */
+    isEntry(rawElement: any): rawElement is [K, V];
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `clear` function clears all the entries in a data structure and resets its properties.
      */
     clear(): void;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function creates a new instance of a `LinkedHashMap` with the same key-value pairs as
+     * the original.
+     * @returns The `clone()` method is returning a new instance of `LinkedHashMap<K, V>` that is a clone
+     * of the original `LinkedHashMap` object.
+     */
     clone(): LinkedHashMap<K, V>;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -262,6 +467,11 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V>;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -280,23 +490,39 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
-    put(key: K, value: V): boolean;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * 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.
      */
-    protected _hashFn: (key: K) => string;
-    protected _objHashFn: (key: K) => object;
+    put(key: K, value: V): boolean;
     /**
-     * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
+     * 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)
+     * where n is the number of entries in the LinkedHashMap.
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
     protected _getIterator(): Generator<[K, V], void, unknown>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)