queue-typed 1.47.3 → 1.47.5

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

@@ -143,7 +143,7 @@ export declare class HashMap<K = any, V = any> {
      * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
      * satisfy the given predicate function.
      */
-    filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V>;
+    filter(predicate: (element: [K, V], index: number, map: HashMap<K, V>) => boolean): HashMap<K, V>;
     /**
      * The `map` function takes a callback function and returns a new HashMap with the values transformed
      * by the callback.
@@ -151,7 +151,7 @@ export declare class HashMap<K = any, V = any> {
      * `map`.
      * @returns a new HashMap object with the values mapped according to the provided callback function.
      */
-    map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV>;
+    map<NV>(callback: (element: [K, V], index: number, map: HashMap<K, V>) => NV): HashMap<K, NV>;
     /**
      * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
      * each element, accumulating a single value.
@@ -164,7 +164,7 @@ export declare class HashMap<K = any, V = any> {
      * @returns The `reduce` function is returning the final value of the accumulator after iterating
      * over all the elements in the HashMap and applying the callback function to each element.
      */
-    reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A;
+    reduce<A>(callback: (accumulator: A, element: [K, V], index: number, 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)

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

@@ -287,10 +287,12 @@ class HashMap {
      */
     filter(predicate) {
         const filteredMap = new HashMap();
+        let index = 0;
         for (const [key, value] of this) {
-            if (predicate([key, value], this)) {
+            if (predicate([key, value], index, this)) {
                 filteredMap.set(key, value);
             }
+            index++;
         }
         return filteredMap;
     }
@@ -303,9 +305,11 @@ class HashMap {
      */
     map(callback) {
         const mappedMap = new HashMap();
+        let index = 0;
         for (const [key, value] of this) {
-            const newValue = callback([key, value], this);
+            const newValue = callback([key, value], index, this);
             mappedMap.set(key, newValue);
+            index++;
         }
         return mappedMap;
     }
@@ -323,8 +327,10 @@ class HashMap {
      */
     reduce(callback, initialValue) {
         let accumulator = initialValue;
-        for (const element of this) {
-            accumulator = callback(accumulator, element, this);
+        let index = 0;
+        for (const entry of this) {
+            accumulator = callback(accumulator, entry, index, this);
+            index++;
         }
         return accumulator;
     }

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

@@ -8,11 +8,11 @@
 export declare class HashTableNode<K, V> {
     key: K;
     value: V;
-    next: HashTableNode<K, V> | null;
+    next: HashTableNode<K, V> | undefined;
     constructor(key: K, value: V);
 }
 import { HashFunction } from '../../types';
-export declare class HashTable<K, V> {
+export declare class HashTable<K = any, V = any> {
     protected static readonly DEFAULT_CAPACITY = 16;
     protected static readonly LOAD_FACTOR = 0.75;
     constructor(capacity?: number, hashFn?: HashFunction<K>);
@@ -20,8 +20,8 @@ export declare class HashTable<K, V> {
     get capacity(): number;
     protected _size: number;
     get size(): number;
-    protected _buckets: Array<HashTableNode<K, V> | null>;
-    get buckets(): Array<HashTableNode<K, V> | null>;
+    protected _buckets: Array<HashTableNode<K, V> | undefined>;
+    get buckets(): Array<HashTableNode<K, V> | undefined>;
     protected _hashFn: HashFunction<K>;
     get hashFn(): HashFunction<K>;
     /**
@@ -50,6 +50,11 @@ export declare class HashTable<K, V> {
      * any value.
      */
     delete(key: K): void;
+    [Symbol.iterator](): Generator<[K, V], void, undefined>;
+    forEach(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => void): void;
+    filter(predicate: (entry: [K, V], index: number, table: HashTable<K, V>) => boolean): HashTable<K, V>;
+    map<T>(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => T): HashTable<K, T>;
+    reduce<T>(callback: (accumulator: T, entry: [K, V], index: number, table: HashTable<K, V>) => T, initialValue: T): T;
     /**
      * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
      * capacity of the data structure.

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

@@ -12,7 +12,7 @@ class HashTableNode {
     constructor(key, value) {
         this.key = key;
         this.value = value;
-        this.next = null;
+        this.next = undefined;
     }
 }
 exports.HashTableNode = HashTableNode;
@@ -21,7 +21,7 @@ class HashTable {
         this._hashFn = hashFn || this._defaultHashFn;
         this._capacity = Math.max(capacity, HashTable.DEFAULT_CAPACITY);
         this._size = 0;
-        this._buckets = new Array(this._capacity).fill(null);
+        this._buckets = new Array(this._capacity).fill(undefined);
     }
     get capacity() {
         return this._capacity;
@@ -101,7 +101,7 @@ class HashTable {
     delete(key) {
         const index = this._hash(key);
         let currentNode = this._buckets[index];
-        let prevNode = null;
+        let prevNode = undefined;
         while (currentNode) {
             if (currentNode.key === key) {
                 if (prevNode) {
@@ -111,13 +111,58 @@ class HashTable {
                     this._buckets[index] = currentNode.next;
                 }
                 this._size--;
-                currentNode.next = null; // Release memory
+                currentNode.next = undefined; // Release memory
                 return;
             }
             prevNode = currentNode;
             currentNode = currentNode.next;
         }
     }
+    *[Symbol.iterator]() {
+        for (const bucket of this._buckets) {
+            let currentNode = bucket;
+            while (currentNode) {
+                yield [currentNode.key, currentNode.value];
+                currentNode = currentNode.next;
+            }
+        }
+    }
+    forEach(callback) {
+        let index = 0;
+        for (const entry of this) {
+            callback(entry, index, this);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const newTable = new HashTable();
+        let index = 0;
+        for (const [key, value] of this) {
+            if (predicate([key, value], index, this)) {
+                newTable.set(key, value);
+            }
+            index++;
+        }
+        return newTable;
+    }
+    map(callback) {
+        const newTable = new HashTable();
+        let index = 0;
+        for (const [key, value] of this) {
+            newTable.set(key, callback([key, value], index, this));
+            index++;
+        }
+        return newTable;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const entry of this) {
+            accumulator = callback(accumulator, entry, index, this);
+            index++;
+        }
+        return accumulator;
+    }
     /**
      * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
      * capacity of the data structure.
@@ -208,7 +253,7 @@ class HashTable {
      */
     _expand() {
         const newCapacity = this._capacity * 2;
-        const newBuckets = new Array(newCapacity).fill(null);
+        const newBuckets = new Array(newCapacity).fill(undefined);
         for (const bucket of this._buckets) {
             let currentNode = bucket;
             while (currentNode) {

package/dist/data-structures/heap/heap.d.ts

@@ -147,7 +147,7 @@ export declare class Heap<E = any> {
      * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order: DFSOrderPattern): E[];
+    dfs(order?: DFSOrderPattern): E[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -195,6 +195,11 @@ export declare class Heap<E = any> {
      * Fix the entire heap to maintain heap properties.
      */
     fix(): void;
+    [Symbol.iterator](): Generator<E, void, unknown>;
+    forEach(callback: (element: E, index: number, heap: this) => void): void;
+    filter(predicate: (element: E, index: number, heap: Heap<E>) => boolean): Heap<E>;
+    map<T>(callback: (element: E, index: number, heap: Heap<E>) => T, comparator: Comparator<T>): Heap<T>;
+    reduce<T>(callback: (accumulator: T, currentValue: E, currentIndex: number, heap: Heap<E>) => T, initialValue: T): T;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

package/dist/data-structures/heap/heap.js

@@ -204,29 +204,30 @@ class Heap {
      * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order) {
+    dfs(order = 'pre') {
         const result = [];
         // Auxiliary recursive function, traverses the binary heap according to the traversal order
-        const dfsHelper = (index) => {
+        const _dfs = (index) => {
+            const left = 2 * index + 1, right = left + 1;
             if (index < this.size) {
                 if (order === 'in') {
-                    dfsHelper(2 * index + 1);
+                    _dfs(left);
                     result.push(this.elements[index]);
-                    dfsHelper(2 * index + 2);
+                    _dfs(right);
                 }
                 else if (order === 'pre') {
                     result.push(this.elements[index]);
-                    dfsHelper(2 * index + 1);
-                    dfsHelper(2 * index + 2);
+                    _dfs(left);
+                    _dfs(right);
                 }
                 else if (order === 'post') {
-                    dfsHelper(2 * index + 1);
-                    dfsHelper(2 * index + 2);
+                    _dfs(left);
+                    _dfs(right);
                     result.push(this.elements[index]);
                 }
             }
         };
-        dfsHelper(0); // Traverse starting from the root node
+        _dfs(0); // Traverse starting from the root node
         return result;
     }
     /**
@@ -294,6 +295,47 @@ class Heap {
         for (let i = Math.floor(this.size / 2); i >= 0; i--)
             this._sinkDown(i, this.elements.length >> 1);
     }
+    *[Symbol.iterator]() {
+        for (const element of this.elements) {
+            yield element;
+        }
+    }
+    forEach(callback) {
+        let index = 0;
+        for (const el of this) {
+            callback(el, index, this);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const filteredHeap = new Heap({ comparator: this.comparator });
+        let index = 0;
+        for (const el of this) {
+            if (predicate(el, index, this)) {
+                filteredHeap.push(el);
+            }
+            index++;
+        }
+        return filteredHeap;
+    }
+    map(callback, comparator) {
+        const mappedHeap = new Heap({ comparator: comparator });
+        let index = 0;
+        for (const el of this) {
+            mappedHeap.add(callback(el, index, this));
+            index++;
+        }
+        return mappedHeap;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const el of this) {
+            accumulator = callback(accumulator, el, index, this);
+            index++;
+        }
+        return accumulator;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -249,6 +249,23 @@ export declare class DoublyLinkedList<E = any> {
      * insertion fails.
      */
     insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+     * after which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {E} newValue - The value that you want to insert into the doubly linked list.
+     * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
+     * existing value or node is not found in the doubly linked list.
+     */
+    insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -279,18 +296,6 @@ export declare class DoublyLinkedList<E = any> {
      * deleted from the doubly linked list, and `false` if the value or node was not found in the list.
      */
     delete(valOrNode: E | DoublyLinkedListNode<E> | null): boolean;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     *
-     * The `toArray` function converts a linked list into an array.
-     * @returns The `toArray()` method is returning an array of type `E[]`.
-     */
-    toArray(): E[];
     /**
      * The function checks if a variable has a length greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
@@ -346,6 +351,17 @@ export declare class DoublyLinkedList<E = any> {
      * the callback function. If no value satisfies the condition, it returns `null`.
      */
     findBackward(callback: (value: E) => boolean): E | null;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     */
+    reverse(): void;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -354,21 +370,26 @@ export declare class DoublyLinkedList<E = any> {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayBackward()` function returns an array of type `E[]`.
+     * The `toArray` function converts a linked list into an array.
+     * @returns The `toArray()` method is returning an array of type `E[]`.
      */
-    toArrayBackward(): E[];
+    toArray(): E[];
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      *
-     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toReversedArray()` function returns an array of type `E[]`.
      */
-    reverse(): void;
+    toReversedArray(): E[];
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    [Symbol.iterator](): Generator<E, void, unknown>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -382,7 +403,7 @@ export declare class DoublyLinkedList<E = any> {
      * represents the value of the current node in the linked list, and the index argument represents the index of the
      * current node in the linked list.
      */
-    forEach(callback: (value: E, index: number) => void): void;
+    forEach(callback: (value: E, index: number, list: DoublyLinkedList<E>) => void): void;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -391,14 +412,13 @@ export declare class DoublyLinkedList<E = any> {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
-     * DoublyLinkedList with the transformed values.
-     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-     * the original DoublyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
-     * DoublyLinkedList).
-     * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
+     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the DoublyLinkedList class.
      */
-    map<U>(callback: (value: E) => U): DoublyLinkedList<U>;
+    filter(callback: (value: E, index: number, list: DoublyLinkedList<E>) => boolean): DoublyLinkedList<E>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -407,13 +427,14 @@ export declare class DoublyLinkedList<E = any> {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      *
-     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
-     * elements that satisfy the given callback function.
-     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
-     * It is used to determine whether a value should be included in the filtered list or not.
-     * @returns The filtered list, which is an instance of the DoublyLinkedList class.
+     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
+     * DoublyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+     * the original DoublyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
+     * DoublyLinkedList).
+     * @returns The `map` function is returning a new instance of `DoublyLinkedList<T>` that contains the mapped values.
      */
-    filter(callback: (value: E) => boolean): DoublyLinkedList<E>;
+    map<T>(callback: (value: E, index: number, list: DoublyLinkedList<E>) => T): DoublyLinkedList<T>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
@@ -426,31 +447,10 @@ export declare class DoublyLinkedList<E = any> {
      * single value.
      * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
      * used to perform a specific operation on each element of the linked list.
-     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
      * point for the reduction operation.
      * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
      * elements in the linked list.
      */
-    reduce<U>(callback: (accumulator: U, value: E) => U, initialValue: U): U;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
-     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-     * after which the new value will be inserted. It can be either the value of the existing node or the existing node
-     * itself.
-     * @param {E} newValue - The value that you want to insert into the doubly linked list.
-     * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
-     * existing value or node is not found in the doubly linked list.
-     */
-    insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
-    /**
-     * The function returns an iterator that iterates over the values of a linked list.
-     */
-    [Symbol.iterator](): Generator<E, void, unknown>;
+    reduce<T>(callback: (accumulator: T, value: E, index: number, list: DoublyLinkedList<E>) => T, initialValue: T): T;
 }