binary-tree-typed 2.5.0 → 2.5.2

package/src/data-structures/heap/heap.ts

@@ -8,7 +8,7 @@
 
 import type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '../../types';
 import { IterableElementBase } from '../base';
-import { ERR } from '../../common';
+import { ERR, raise } from '../../common';
 
 /**
  * Binary heap with pluggable comparator; supports fast insertion and removal of the top element.
@@ -196,6 +196,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Track heap capacity
  *  const heap = new Heap<number>();
@@ -270,6 +294,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // basic Heap creation and add operation
  *  // Create a min heap (default)
@@ -305,6 +353,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Add multiple elements
  *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -342,6 +414,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Heap with custom comparator (MaxHeap behavior)
  *  interface Task {
@@ -395,6 +491,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Heap for event processing with priority
  *  interface Event {
@@ -473,6 +593,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check if heap is empty
  *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -498,6 +642,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove all elements
  *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -528,6 +696,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @returns True if found.
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check element existence
  *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -553,6 +745,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove specific element
  *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
@@ -628,6 +844,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @returns Array of visited elements.
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Depth-first traversal
  *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -689,6 +929,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Sort elements using heap
  *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
@@ -720,6 +984,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Create independent copy
  *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
@@ -750,6 +1038,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Filter elements
  *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
@@ -787,6 +1099,30 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Transform elements
  *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -800,7 +1136,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     thisArg?: unknown
   ): Heap<EM, RM> {
     const { comparator, toElementFn, ...rest } = options ?? {};
-    if (!comparator) throw new TypeError(ERR.comparatorRequired('Heap.map'));
+    if (!comparator) raise(TypeError, ERR.comparatorRequired('Heap.map'));
     const out = this._createLike<EM, RM>([], { ...rest, comparator, toElementFn });
     let i = 0;
     for (const x of this) {
@@ -830,7 +1166,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
 
   protected readonly _DEFAULT_COMPARATOR: Comparator<E> = (a: E, b: E): number => {
     if (typeof a === 'object' || typeof b === 'object') {
-      throw new TypeError(ERR.comparatorRequired('Heap'));
+      raise(TypeError, ERR.comparatorRequired('Heap'));
     }
     if (a > b) return 1;
     if (a < b) return -1;
@@ -972,7 +1308,7 @@ export class FibonacciHeap<E> {
   constructor(comparator?: Comparator<E>) {
     this.clear();
     this._comparator = comparator || this._defaultComparator;
-    if (typeof this.comparator !== 'function') throw new TypeError(ERR.notAFunction('comparator', 'FibonacciHeap'));
+    if (typeof this.comparator !== 'function') raise(TypeError, ERR.notAFunction('comparator', 'FibonacciHeap'));
   }
 
   protected _root?: FibonacciHeapNode<E>;

package/src/data-structures/heap/max-heap.ts

@@ -6,7 +6,7 @@
  */
 import type { HeapOptions } from '../../types';
 import { Heap } from './heap';
-import { ERR } from '../../common';
+import { ERR, raise } from '../../common';
 
 /**
  * @template E
@@ -80,7 +80,7 @@ export class MaxHeap<E = any, R = any> extends Heap<E, R> {
     super(elements, {
       comparator: (a: E, b: E): number => {
         if (typeof a === 'object' || typeof b === 'object') {
-          throw new TypeError(ERR.comparatorRequired('MaxHeap'));
+          raise(TypeError, ERR.comparatorRequired('MaxHeap'));
         }
         if (a < b) return 1;
         if (a > b) return -1;