data-structure-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);
   }
@@ -573,6 +573,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Add a single node
  *  const tree = new BinaryTree<number>();
@@ -607,6 +630,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // basic BinaryTree creation and insertion
  *  // Create a BinaryTree with entries
@@ -703,6 +749,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Bulk add
  *  const tree = new BinaryTree<number>();
@@ -727,6 +796,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Set multiple entries
  *  const tree = new BinaryTree<number, string>();
@@ -777,6 +869,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Combine trees
  *  const t1 = new BinaryTree<number>([1, 2]);
@@ -823,6 +938,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove a node
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -899,6 +1037,29 @@ export class BinaryTree<K = any, V = any, R = any>
   
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Search by predicate
  *  const tree = new BinaryTree<number>([5, 3, 7, 1, 9]);
@@ -1012,6 +1173,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get nodes by condition
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1064,6 +1248,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get node by key
  *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'child']]);
@@ -1110,6 +1317,29 @@ 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']]);
@@ -1149,6 +1379,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // BinaryTree get and has operations
  *  const tree = new BinaryTree(
@@ -1224,6 +1477,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove all nodes
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -1250,6 +1526,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check empty
  *  console.log(new BinaryTree().isEmpty()); // true;
@@ -1288,6 +1587,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check BST property
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -1356,6 +1678,29 @@ 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]);
@@ -1398,6 +1743,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get tree height
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1681,6 +2049,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Depth-first search traversal
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1746,6 +2137,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // BinaryTree level-order traversal
  *  const tree = new BinaryTree([
@@ -1870,6 +2284,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get leaf nodes
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -1947,6 +2384,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Level-order grouping
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -2042,6 +2502,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Morris traversal (O(1) space)
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2181,6 +2664,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Deep copy
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2211,6 +2717,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Filter nodes by condition
  *  const tree = new BinaryTree<number>([1, 2, 3, 4]);
@@ -2245,6 +2774,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Transform to new tree
  *  const tree = new BinaryTree<number, number>([[1, 10], [2, 20]]);
@@ -2312,6 +2864,29 @@ export class BinaryTree<K = any, V = any, R = any>
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Display tree
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -2902,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';
   }