data-structure-typed 1.51.8 → 1.52.0

package/dist/mjs/data-structures/graph/abstract-graph.js

@@ -395,9 +395,8 @@ export class AbstractGraph extends IterableEntryBase {
     }
     /**
      *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
      */
@@ -523,9 +522,8 @@ export class AbstractGraph extends IterableEntryBase {
      * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edgeMap.
      * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(VO^3), where VO is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
      *
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
      * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
      */
@@ -648,9 +646,8 @@ export class AbstractGraph extends IterableEntryBase {
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
      * one to rest pairs
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
      *
@@ -755,9 +752,8 @@ export class AbstractGraph extends IterableEntryBase {
     }
     /**
      * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
-     * /
-  
-     /**
+     */
+    /**
      * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
      * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
      */
@@ -773,9 +769,8 @@ export class AbstractGraph extends IterableEntryBase {
      * Not support graph with negative weight cycle
      * all pairs
      * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
      * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
      *

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

@@ -8,20 +8,21 @@
 import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem, LinkedHashMapOptions } from '../../types';
 import { IterableEntryBase } from '../base';
 /**
- * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
+ * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key map to a value.
  * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries based on a key.
- * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
+ * 3. Unique Keys: Keys are unique.
+ * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 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> {
     /**
      * The constructor function initializes a HashMap object with an optional initial collection and
      * options.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `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 | [K, V]>, options?: HashMapOptions<K, V, R>);
+    constructor(entryOrRawElements?: Iterable<R | [K, V]>, options?: HashMapOptions<K, V, R>);
     protected _store: {
         [key: string]: HashMapStoreItem<K, V>;
     };
@@ -40,12 +41,12 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * `object` and values of type `V`.
      */
     get objMap(): Map<object, V>;
-    protected _toEntryFn: (rawElement: R) => [K, 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];
+    get toEntryFn(): ((rawElement: R) => [K, V]) | undefined;
     protected _size: number;
     /**
      * The function returns the size of an object.
@@ -90,11 +91,11 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
     /**
      * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
      * pair using a mapping function, and sets each key-value pair in the current object.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `T`.
      * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(rawCollection: Iterable<R | [K, V]>): boolean[];
+    setMany(entryOrRawElements: 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.
@@ -149,7 +150,7 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
      * the provided callback function.
      */
-    map<U>(callbackfn: EntryCallback<K, V, U>, thisArg?: any): HashMap<K, U>;
+    map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: any): HashMap<K, VM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -205,14 +206,14 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     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
+     * @param entryOrRawElements - The `entryOrRawElements` 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
+     * `entryOrRawElements` 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>);
+    constructor(entryOrRawElements?: 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.
@@ -243,7 +244,7 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * 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`.
+     * a value type `V | undefined`.
      */
     get head(): HashMapLinkedNode<K, V | undefined>;
     protected _tail: HashMapLinkedNode<K, V | undefined>;
@@ -320,11 +321,11 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * 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
+     * @param entryOrRawElements - The entryOrRawElements parameter is an iterable collection of elements of type
      * R.
      * @returns The `setMany` function returns an array of booleans.
      */
-    setMany(rawCollection: Iterable<R>): boolean[];
+    setMany(entryOrRawElements: 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.
@@ -353,9 +354,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -370,9 +370,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -386,9 +385,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -401,9 +399,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -422,9 +419,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -448,9 +444,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -469,9 +464,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -488,7 +482,7 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
      * function.
      */
-    map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
+    map<VM>(callback: EntryCallback<K, V, VM>, thisArg?: any): LinkedHashMap<K, VM>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -509,9 +503,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * 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.

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

@@ -1,20 +1,21 @@
 import { IterableEntryBase } from '../base';
 import { isWeakKey, rangeCheck } from '../../utils';
 /**
- * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
+ * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key map to a value.
  * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries based on a key.
- * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
+ * 3. Unique Keys: Keys are unique.
+ * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 export class HashMap extends IterableEntryBase {
     /**
      * The constructor function initializes a HashMap object with an optional initial collection and
      * options.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `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 = [], options) {
+    constructor(entryOrRawElements = [], options) {
         super();
         if (options) {
             const { hashFn, toEntryFn } = options;
@@ -25,8 +26,8 @@ export class HashMap extends IterableEntryBase {
                 this._toEntryFn = toEntryFn;
             }
         }
-        if (rawCollection) {
-            this.setMany(rawCollection);
+        if (entryOrRawElements) {
+            this.setMany(entryOrRawElements);
         }
     }
     _store = {};
@@ -47,15 +48,7 @@ export class HashMap extends IterableEntryBase {
     get objMap() {
         return this._objMap;
     }
-    _toEntryFn = (rawElement) => {
-        if (this.isEntry(rawElement)) {
-            // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
-            return rawElement;
-        }
-        else {
-            throw new Error("If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified.");
-        }
-    };
+    _toEntryFn;
     /**
      * The function returns the value of the _toEntryFn property.
      * @returns The function being returned is `this._toEntryFn`.
@@ -134,24 +127,25 @@ export class HashMap extends IterableEntryBase {
     /**
      * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
      * pair using a mapping function, and sets each key-value pair in the current object.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `T`.
      * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(rawCollection) {
+    setMany(entryOrRawElements) {
         const results = [];
-        for (const rawEle of rawCollection) {
+        for (const rawEle of entryOrRawElements) {
             let key, value;
             if (this.isEntry(rawEle)) {
                 key = rawEle[0];
                 value = rawEle[1];
             }
-            else {
+            else if (this.toEntryFn) {
                 const item = this.toEntryFn(rawEle);
                 key = item[0];
                 value = item[1];
             }
-            results.push(this.set(key, value));
+            if (key !== undefined && value !== undefined)
+                results.push(this.set(key, value));
         }
         return results;
     }
@@ -343,14 +337,14 @@ export class LinkedHashMap extends IterableEntryBase {
     _sentinel;
     /**
      * 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
+     * @param entryOrRawElements - The `entryOrRawElements` 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
+     * `entryOrRawElements` 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 = [], options) {
+    constructor(entryOrRawElements = [], options) {
         super();
         this._sentinel = {};
         this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
@@ -364,8 +358,8 @@ export class LinkedHashMap extends IterableEntryBase {
                 this._toEntryFn = toEntryFn;
             }
         }
-        if (rawCollection) {
-            for (const el of rawCollection) {
+        if (entryOrRawElements) {
+            for (const el of entryOrRawElements) {
                 const [key, value] = this.toEntryFn(el);
                 this.set(key, value);
             }
@@ -409,7 +403,7 @@ export class LinkedHashMap extends IterableEntryBase {
     /**
      * 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`.
+     * a value type `V | undefined`.
      */
     get head() {
         return this._head;
@@ -428,7 +422,7 @@ export class LinkedHashMap extends IterableEntryBase {
             return rawElement;
         }
         else {
-            throw new Error("If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified.");
+            throw new Error("If the provided entryOrRawElements does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified.");
         }
     };
     /**
@@ -524,7 +518,7 @@ export class LinkedHashMap extends IterableEntryBase {
             const hash = this.objHashFn(key);
             node = this.objMap.get(hash);
             if (!node && isNewKey) {
-                // Create new node
+                // Create a new node
                 node = { key: hash, value, prev: this.tail, next: this._sentinel };
                 this.objMap.set(hash, node);
             }
@@ -564,13 +558,13 @@ export class LinkedHashMap extends IterableEntryBase {
      * 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
+     * @param entryOrRawElements - The entryOrRawElements parameter is an iterable collection of elements of type
      * R.
      * @returns The `setMany` function returns an array of booleans.
      */
-    setMany(rawCollection) {
+    setMany(entryOrRawElements) {
         const results = [];
-        for (const rawEle of rawCollection) {
+        for (const rawEle of entryOrRawElements) {
             const [key, value] = this.toEntryFn(rawEle);
             results.push(this.set(key, value));
         }
@@ -624,9 +618,8 @@ export class LinkedHashMap extends IterableEntryBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -648,9 +641,8 @@ export class LinkedHashMap extends IterableEntryBase {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -689,9 +681,8 @@ export class LinkedHashMap extends IterableEntryBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -711,9 +702,8 @@ export class LinkedHashMap extends IterableEntryBase {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -736,9 +726,8 @@ export class LinkedHashMap extends IterableEntryBase {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -773,9 +762,8 @@ export class LinkedHashMap extends IterableEntryBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -804,9 +792,8 @@ export class LinkedHashMap extends IterableEntryBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -855,9 +842,8 @@ export class LinkedHashMap extends IterableEntryBase {
      * 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.