binary-tree-typed 2.5.0 → 2.5.2

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

@@ -28,7 +28,7 @@ import { IBinaryTree } from '../../interfaces';
 import { isComparable, makeTrampoline, makeTrampolineThunk } from '../../utils';
 import { Queue } from '../queue';
 import { IterableEntryBase } from '../base';
-import { DFSOperation, ERR, Range } from '../../common';
+import { DFSOperation, ERR, raise, Range } from '../../common';
 
 /**
  * @template K - The type of the key.
@@ -216,7 +216,7 @@ export class BinaryTreeNode<K = any, V = any> {
  *       node?: BinaryTreeNode<string> | null,
  *       conditions?: { [key: string]: boolean }
  *     ): string {
- *       if (!node) throw new Error('Invalid node');
+ *       if (!node) raise(Error, 'Invalid node');
  *
  *       // If it's a leaf node, return the decision result
  *       if (!node.left && !node.right) return node.key;
@@ -261,7 +261,7 @@ export class BinaryTreeNode<K = any, V = any> {
  *         case '/':
  *           return rightValue !== 0 ? leftValue / rightValue : 0; // Handle division by zero
  *         default:
- *           throw new Error(`Unsupported operator: ${node.key}`);
+ *           raise(Error, `Unsupported operator: ${node.key}`);
  *       }
  *     }
  *
@@ -293,7 +293,7 @@ export class BinaryTree<K = any, V = any, R = any>
       if (isMapMode !== undefined) this._isMapMode = isMapMode;
       if (isDuplicate !== undefined) this._isDuplicate = isDuplicate;
       if (typeof toEntryFn === 'function') this._toEntryFn = toEntryFn;
-      else if (toEntryFn) throw new TypeError(ERR.notAFunction('toEntryFn', 'BinaryTree'));
+      else if (toEntryFn) raise(TypeError, ERR.notAFunction('toEntryFn', 'BinaryTree'));
     }
 
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
@@ -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,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Add a single node
  *  const tree = new BinaryTree<number>();
@@ -605,6 +629,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // basic BinaryTree creation and insertion
  *  // Create a BinaryTree with entries
@@ -700,6 +748,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Bulk add
  *  const tree = new BinaryTree<number>();
@@ -723,6 +795,30 @@ 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 +868,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Combine trees
  *  const t1 = new BinaryTree<number>([1, 2]);
@@ -817,6 +937,30 @@ 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 +1036,30 @@ 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 +1172,30 @@ 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 +1247,30 @@ 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 +1316,30 @@ 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 +1378,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // BinaryTree get and has operations
  *  const tree = new BinaryTree(
@@ -1212,6 +1476,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove all nodes
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -1237,6 +1525,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check empty
  *  console.log(new BinaryTree().isEmpty()); // true;
@@ -1274,6 +1586,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check BST property
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -1341,6 +1677,30 @@ 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 +1742,30 @@ 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 +2048,30 @@ 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 +2136,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // BinaryTree level-order traversal
  *  const tree = new BinaryTree([
@@ -1851,6 +2283,30 @@ 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 +2383,30 @@ 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 +2501,30 @@ 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 +2663,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Deep copy
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2188,6 +2716,30 @@ 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 +2773,30 @@ 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 +2863,30 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Display tree
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2877,7 +3477,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';
   }