priority-queue-typed 1.54.2 → 2.0.0

package/dist/data-structures/binary-tree/tree-multi-map.js

@@ -41,11 +41,169 @@ exports.TreeMultiMapNode = TreeMultiMapNode;
 /**
  *
  * @example
- * // Find elements in a range
- *     const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(tmm.search(new Range(5, 10))); // [5, 10, 7]
- *     console.log(tmm.search(new Range(4, 12))); // [5, 10, 12, 7]
- *     console.log(tmm.search(new Range(15, 20))); // [15, 18]
+ * // players ranked by score with their equipment
+ *     type Equipment = {
+ *       name: string; // Equipment name
+ *       quality: 'legendary' | 'epic' | 'rare' | 'common';
+ *       level: number;
+ *     };
+ *
+ *     type Player = {
+ *       name: string;
+ *       score: number;
+ *       equipments: Equipment[];
+ *     };
+ *
+ *     // Mock player data with their scores and equipment
+ *     const players: Player[] = [
+ *       {
+ *         name: 'DragonSlayer',
+ *         score: 8750,
+ *         equipments: [
+ *           { name: 'AWM', quality: 'legendary', level: 85 },
+ *           { name: 'Level 3 Helmet', quality: 'epic', level: 80 },
+ *           { name: 'Extended Quickdraw Mag', quality: 'rare', level: 75 },
+ *           { name: 'Compensator', quality: 'epic', level: 78 },
+ *           { name: 'Vertical Grip', quality: 'rare', level: 72 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'ShadowNinja',
+ *         score: 7200,
+ *         equipments: [
+ *           { name: 'M416', quality: 'epic', level: 75 },
+ *           { name: 'Ghillie Suit', quality: 'rare', level: 70 },
+ *           { name: 'Red Dot Sight', quality: 'common', level: 65 },
+ *           { name: 'Extended QuickDraw Mag', quality: 'rare', level: 68 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'RuneMaster',
+ *         score: 9100,
+ *         equipments: [
+ *           { name: 'KAR98K', quality: 'legendary', level: 90 },
+ *           { name: 'Level 3 Vest', quality: 'legendary', level: 85 },
+ *           { name: 'Holographic Sight', quality: 'epic', level: 82 },
+ *           { name: 'Suppressor', quality: 'legendary', level: 88 },
+ *           { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'BattleKing',
+ *         score: 8500,
+ *         equipments: [
+ *           { name: 'AUG', quality: 'epic', level: 82 },
+ *           { name: 'Red Dot Sight', quality: 'rare', level: 75 },
+ *           { name: 'Extended Mag', quality: 'common', level: 70 },
+ *           { name: 'Tactical Stock', quality: 'rare', level: 76 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'SniperElite',
+ *         score: 7800,
+ *         equipments: [
+ *           { name: 'M24', quality: 'legendary', level: 88 },
+ *           { name: 'Compensator', quality: 'epic', level: 80 },
+ *           { name: 'Scope 8x', quality: 'legendary', level: 85 },
+ *           { name: 'Level 2 Helmet', quality: 'rare', level: 75 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'RushMaster',
+ *         score: 7500,
+ *         equipments: [
+ *           { name: 'Vector', quality: 'rare', level: 72 },
+ *           { name: 'Level 2 Helmet', quality: 'common', level: 65 },
+ *           { name: 'Quickdraw Mag', quality: 'common', level: 60 },
+ *           { name: 'Laser Sight', quality: 'rare', level: 68 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'GhostWarrior',
+ *         score: 8200,
+ *         equipments: [
+ *           { name: 'SCAR-L', quality: 'epic', level: 78 },
+ *           { name: 'Extended Quickdraw Mag', quality: 'rare', level: 70 },
+ *           { name: 'Holographic Sight', quality: 'epic', level: 75 },
+ *           { name: 'Suppressor', quality: 'rare', level: 72 },
+ *           { name: 'Vertical Grip', quality: 'common', level: 65 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'DeathDealer',
+ *         score: 7300,
+ *         equipments: [
+ *           { name: 'SKS', quality: 'epic', level: 76 },
+ *           { name: 'Holographic Sight', quality: 'rare', level: 68 },
+ *           { name: 'Extended Mag', quality: 'common', level: 65 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'StormRider',
+ *         score: 8900,
+ *         equipments: [
+ *           { name: 'MK14', quality: 'legendary', level: 92 },
+ *           { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+ *           { name: 'Scope 8x', quality: 'epic', level: 80 },
+ *           { name: 'Suppressor', quality: 'legendary', level: 88 },
+ *           { name: 'Tactical Stock', quality: 'rare', level: 75 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'CombatLegend',
+ *         score: 7600,
+ *         equipments: [
+ *           { name: 'UMP45', quality: 'rare', level: 74 },
+ *           { name: 'Level 2 Vest', quality: 'common', level: 67 },
+ *           { name: 'Red Dot Sight', quality: 'common', level: 62 },
+ *           { name: 'Extended Mag', quality: 'rare', level: 70 }
+ *         ]
+ *       }
+ *     ];
+ *
+ *     // Create a TreeMultiMap for player rankings
+ *     const playerRankings = new TreeMultiMap<number, Equipment, Player>(players, {
+ *       toEntryFn: ({ score, equipments }) => [score, equipments],
+ *       isMapMode: false
+ *     });
+ *
+ *     const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+ *     console.log(topPlayersEquipments); // [
+ *  //      [
+ *  //        {
+ *  //          name: 'MK14',
+ *  //          quality: 'legendary',
+ *  //          level: 92
+ *  //        },
+ *  //        { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+ *  //        {
+ *  //          name: 'Scope 8x',
+ *  //          quality: 'epic',
+ *  //          level: 80
+ *  //        },
+ *  //        { name: 'Suppressor', quality: 'legendary', level: 88 },
+ *  //        {
+ *  //          name: 'Tactical Stock',
+ *  //          quality: 'rare',
+ *  //          level: 75
+ *  //        }
+ *  //      ],
+ *  //      [
+ *  //        { name: 'KAR98K', quality: 'legendary', level: 90 },
+ *  //        {
+ *  //          name: 'Level 3 Vest',
+ *  //          quality: 'legendary',
+ *  //          level: 85
+ *  //        },
+ *  //        { name: 'Holographic Sight', quality: 'epic', level: 82 },
+ *  //        {
+ *  //          name: 'Suppressor',
+ *  //          quality: 'legendary',
+ *  //          level: 88
+ *  //        },
+ *  //        { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+ *  //      ]
+ *  //    ]
  */
 class TreeMultiMap extends red_black_tree_1.RedBlackTree {
     /**
@@ -60,7 +218,7 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      * additional options for configuring the TreeMultiMap instance.
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
-        super([], Object.assign(Object.assign({}, options), { isMapMode: true }));
+        super([], Object.assign({}, options));
         if (keysNodesEntriesOrRaws) {
             this.addMany(keysNodesEntriesOrRaws);
         }
@@ -79,34 +237,36 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      * data and the provided options merged with the existing properties of the current object.
      */
     createTree(options) {
-        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
+        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse, isMapMode: this._isMapMode }, options));
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `createNode` overrides the method to create a new `TreeMultiMapNode` with a specified
-     * key and an empty array of values.
-     * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
-     * that will be created in the TreeMultiMap data structure.
-     * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned, with the specified key and
-     * an empty array as its value.
+     * The function `createNode` overrides the creation of a new TreeMultiMapNode with a specified key
+     * and value array.
+     * @param {K} key - The `key` parameter represents the key of the node being created in the
+     * `TreeMultiMap`.
+     * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
+     * values associated with a specific key in the TreeMultiMap data structure.
+     * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned with the specified key and
+     * value. If `_isMapMode` is true, an empty array is passed as the value, otherwise the provided
+     * value is used.
      */
-    createNode(key) {
-        return new TreeMultiMapNode(key, []);
+    createNode(key, value = []) {
+        return new TreeMultiMapNode(key, this._isMapMode ? [] : value);
     }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
-     * The function `add` in TypeScript overrides the superclass method to add key-value pairs to a
-     * TreeMultiMapNode, handling different input types and scenarios.
-     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `override add` method can be either a `BTNRep` object containing a key, an array
-     * of values, and a `TreeMultiMapNode`, or just a key.
-     * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
-     * you want to add to the TreeMultiMap. If the key is already present in the map, the new value will
-     * be added to the existing list of values associated with that key. If the key is not present,
+     * The function overrides the add method to handle different types of input for a TreeMultiMap data
+     * structure.
+     * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
+     * be added to the TreeMultiMap. It can be of type `K`, which is the key type of the TreeMultiMap, or
+     * it can be a TreeMultiMapNode containing the key and its
+     * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
+     * that you want to add to the TreeMultiMap. It can contain one or more values of type `V`.
      * @returns The `add` method is returning a boolean value, which indicates whether the operation was
      * successful or not.
      */
@@ -116,30 +276,40 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
         const _commonAdd = (key, values) => {
             if (key === undefined || key === null)
                 return false;
-            const existingValues = this.get(key);
-            if (existingValues !== undefined && values !== undefined) {
-                for (const value of values)
-                    existingValues.push(value);
-                return true;
-            }
-            const existingNode = this.getNode(key);
-            if (this.isRealNode(existingNode)) {
-                if (existingValues === undefined) {
-                    super.add(key, values);
-                    return true;
-                }
-                if (values !== undefined) {
+            const _addToValues = () => {
+                const existingValues = this.get(key);
+                if (existingValues !== undefined && values !== undefined) {
                     for (const value of values)
                         existingValues.push(value);
                     return true;
                 }
+                return false;
+            };
+            const _addByNode = () => {
+                const existingNode = this.getNode(key);
+                if (this.isRealNode(existingNode)) {
+                    const existingValues = this.get(existingNode);
+                    if (existingValues === undefined) {
+                        super.add(key, values);
+                        return true;
+                    }
+                    if (values !== undefined) {
+                        for (const value of values)
+                            existingValues.push(value);
+                        return true;
+                    }
+                    else {
+                        return false;
+                    }
+                }
                 else {
-                    return false;
+                    return super.add(key, values);
                 }
+            };
+            if (this._isMapMode) {
+                return _addByNode() || _addToValues();
             }
-            else {
-                return super.add(key, values);
-            }
+            return _addToValues() || _addByNode();
         };
         if (this.isEntry(keyNodeOrEntry)) {
             const [key, values] = keyNodeOrEntry;
@@ -153,7 +323,7 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      *
      * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
      * and deletes the entire node if no values are left for that key.
-     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
      * array of values, or just a key itself.
      * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific

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

@@ -267,8 +267,8 @@ class AbstractGraph extends base_1.IterableEntryBase {
             const queue = new queue_1.Queue([vertex1]);
             visited.set(vertex1, true);
             let cost = 0;
-            while (queue.size > 0) {
-                for (let i = 0; i < queue.size; i++) {
+            while (queue.length > 0) {
+                for (let i = 0; i < queue.length; i++) {
                     const cur = queue.shift();
                     if (cur === vertex2) {
                         return cost;

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

@@ -183,7 +183,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>> {
+export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     /**
      * The constructor initializes a heap data structure with optional elements and options.
      * @param elements - The `elements` parameter is an iterable object that contains the initial
@@ -308,14 +308,6 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      * @returns An array containing elements traversed in the specified order.
      */
     dfs(order?: DFSOrderPattern): E[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * Convert the heap to an array.
-     * @returns An array containing the elements of the heap.
-     */
-    toArray(): E[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -355,7 +347,7 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
      * the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, R, boolean, Heap<E, R>>, thisArg?: any): Heap<E, R>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): Heap<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -377,7 +369,7 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      * value of
      * @returns a new instance of the `Heap` class with the mapped elements.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, Heap<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Heap<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Heap<EM, RM>;
     protected _DEFAULT_COMPARATOR: (a: E, b: E) => number;
     protected _comparator: Comparator<E>;
     /**

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

@@ -413,16 +413,6 @@ class Heap extends base_1.IterableElementBase {
         _dfs(0); // Traverse starting from the root node
         return result;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * Convert the heap to an array.
-     * @returns An array containing the elements of the heap.
-     */
-    toArray() {
-        return [...this.elements];
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -42,7 +42,7 @@ export declare class MaxHeap<E = any, R = any> extends Heap<E, R> {
      * @returns The `filter` method is returning a new `MaxHeap` object that contains the elements that pass
      * the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, R, boolean, MaxHeap<E, R>>, thisArg?: any): MaxHeap<E, R>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MaxHeap<E, R>;
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -64,5 +64,5 @@ export declare class MaxHeap<E = any, R = any> extends Heap<E, R> {
      * value of
      * @returns a new instance of the `MaxHeap` class with the mapped elements.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, MaxHeap<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MaxHeap<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MaxHeap<EM, RM>;
 }

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

@@ -42,7 +42,7 @@ export declare class MinHeap<E = any, R = any> extends Heap<E, R> {
      * @returns The `filter` method is returning a new `MinHeap` object that contains the elements that pass
      * the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, R, boolean, MinHeap<E, R>>, thisArg?: any): MinHeap<E, R>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MinHeap<E, R>;
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -64,5 +64,5 @@ export declare class MinHeap<E = any, R = any> extends Heap<E, R> {
      * value of
      * @returns a new instance of the `MinHeap` class with the mapped elements.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, MinHeap<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MinHeap<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MinHeap<EM, RM>;
 }