max-priority-queue-typed 2.5.0 → 2.5.1

package/src/data-structures/binary-tree/binary-tree.ts

@@ -555,7 +555,7 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param key - The key to validate.
    * @returns True if the key is valid, false otherwise.
    */
-  isValidKey(key: any): key is K {
+  isValidKey(key: unknown): key is K {
     if (key === null) return true;
     return isComparable(key);
   }
@@ -572,6 +572,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Add a single node
  *  const tree = new BinaryTree<number>();
@@ -605,6 +626,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // basic BinaryTree creation and insertion
  *  // Create a BinaryTree with entries
@@ -700,6 +742,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Bulk add
  *  const tree = new BinaryTree<number>();
@@ -723,6 +786,27 @@ export class BinaryTree<K = any, V = any, R = any>
    * @returns An array of booleans indicating the success of each individual `set` operation.
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Set multiple entries
  *  const tree = new BinaryTree<number, string>();
@@ -772,6 +856,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Combine trees
  *  const t1 = new BinaryTree<number>([1, 2]);
@@ -817,6 +922,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove a node
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -892,6 +1018,27 @@ export class BinaryTree<K = any, V = any, R = any>
    * Search by predicate
   
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Search by predicate
  *  const tree = new BinaryTree<number>([5, 3, 7, 1, 9]);
@@ -1004,6 +1151,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get nodes by condition
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1055,6 +1223,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get node by key
  *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'child']]);
@@ -1100,6 +1289,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Retrieve value by key
  *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'left'], [3, 'right']]);
@@ -1138,6 +1348,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // BinaryTree get and has operations
  *  const tree = new BinaryTree(
@@ -1212,6 +1443,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove all nodes
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -1237,6 +1489,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check empty
  *  console.log(new BinaryTree().isEmpty()); // true;
@@ -1274,6 +1547,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check BST property
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -1341,6 +1635,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get depth of a node
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1382,6 +1697,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get tree height
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1664,6 +2000,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Depth-first search traversal
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1728,6 +2085,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // BinaryTree level-order traversal
  *  const tree = new BinaryTree([
@@ -1851,6 +2229,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get leaf nodes
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1927,6 +2326,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Level-order grouping
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -2021,6 +2441,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Morris traversal (O(1) space)
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2159,6 +2600,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Deep copy
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2188,6 +2650,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Filter nodes by condition
  *  const tree = new BinaryTree<number>([1, 2, 3, 4]);
@@ -2221,6 +2704,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Transform to new tree
  *  const tree = new BinaryTree<number, number>([[1, 10], [2, 20]]);
@@ -2287,6 +2791,27 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Display tree
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2877,7 +3402,7 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param p - The item to check.
    * @returns True if it's a function.
    */
-  protected _isPredicate(p: any): p is NodePredicate<BinaryTreeNode<K, V>> {
+  protected _isPredicate(p: unknown): p is NodePredicate<BinaryTreeNode<K, V>> {
     return typeof p === 'function';
   }