binary-tree-typed 2.5.1 → 2.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "binary-tree-typed",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "Binary Tree. Javascript & Typescript Data Structure.",
   "browser": "dist/umd/binary-tree-typed.min.js",
   "umd:main": "dist/umd/binary-tree-typed.min.js",
@@ -178,6 +178,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^2.5.1"
+    "data-structure-typed": "^2.5.3"
   }
 }

package/src/common/error.ts

@@ -1,3 +1,17 @@
+/**
+ * Centralized error dispatch.
+ * All library errors go through this function for consistent messaging and easy grep.
+ * @remarks Always throws — data structure errors are never recoverable.
+ * @param ErrorClass - The error constructor (Error, TypeError, RangeError, etc.)
+ * @param message - The error message.
+ */
+export function raise(
+  ErrorClass: new (msg: string) => Error,
+  message: string
+): never {
+  throw new ErrorClass(message);
+}
+
 /**
  * Centralized error message templates.
  * Keep using native Error/TypeError/RangeError — this only standardizes messages.
@@ -56,5 +70,9 @@ export const ERR = {
     'Matrix: Must be rectangular for transposition.',
 
   matrixRowMismatch: (expected: number, got: number) =>
-    `Matrix: Expected row length ${expected}, but got ${got}.`
+    `Matrix: Expected row length ${expected}, but got ${got}.`,
+
+  // Order statistic
+  orderStatisticNotEnabled: (method: string, ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}${method}() requires enableOrderStatistic: true.`
 } as const;

package/src/common/index.ts

@@ -1,4 +1,4 @@
-export { ERR } from './error';
+export { ERR, raise } from './error';
 
 export enum DFSOperation {
   VISIT = 0,

package/src/data-structures/base/iterable-element-base.ts

@@ -1,4 +1,5 @@
 import type { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';
+import { raise } from '../../common';
 
 /**
  * Base class that makes a data structure iterable and provides common
@@ -25,7 +26,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
     if (options) {
       const { toElementFn } = options;
       if (typeof toElementFn === 'function') this._toElementFn = toElementFn;
-      else if (toElementFn) throw new TypeError('toElementFn must be a function type');
+      else if (toElementFn) raise(TypeError, 'toElementFn must be a function type');
     }
   }
 
@@ -224,7 +225,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
       acc = initialValue as U;
     } else {
       const first = iter.next();
-      if (first.done) throw new TypeError('Reduce of empty structure with no initial value');
+      if (first.done) raise(TypeError, 'Reduce of empty structure with no initial value');
       acc = first.value as unknown as U;
       index = 1;
     }

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

@@ -9,7 +9,6 @@
 import { BST } from './bst';
 import type {
   AVLTreeOptions,
-  BinaryTreeDeleteResult,
   BinaryTreeOptions,
   BSTNOptKeyOrNode,
   EntryCallback,
@@ -459,6 +458,34 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -579,6 +606,27 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -609,15 +657,15 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    */
   override delete(
     keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
-  ): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[] {
-    const deletedResults = super.delete(keyNodeOrEntry);
+  ): boolean {
+    const deletedResults = this._deleteInternal(keyNodeOrEntry);
     // After deletion, balance the path from the parent of the *physically deleted* node.
     for (const { needBalanced } of deletedResults) {
       if (needBalanced) {
-        this._balancePath(needBalanced);
+        this._balancePath(needBalanced as AVLTreeNode<K, V>);
       }
     }
-    return deletedResults;
+    return deletedResults.length > 0;
   }
 
   /**
@@ -666,6 +714,20 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -794,6 +856,27 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -970,6 +1053,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
 
   /**
@@ -1022,6 +1107,9 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
 
   /**
@@ -1061,6 +1149,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
 
   /**
@@ -1112,6 +1202,9 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
 
   /**
@@ -1130,6 +1223,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
       const A = path[i];
       if (A) {
         this._updateHeight(A);
+        this._updateCount(A);
 
         // Check the balance factor
         switch (this._balanceFactor(A)) {

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { ERR } from '../../common';
+import { ERR, raise } from '../../common';
 
 /**
  * Binary Indexed Tree (Fenwick Tree).
@@ -44,7 +44,7 @@ export class BinaryIndexedTree implements Iterable<number> {
       }
     } else {
       if (!Number.isInteger(sizeOrElements) || sizeOrElements < 0) {
-        throw new RangeError(ERR.invalidArgument('size must be a non-negative integer', 'BinaryIndexedTree'));
+        raise(RangeError, ERR.invalidArgument('size must be a non-negative integer', 'BinaryIndexedTree'));
       }
       this._size = sizeOrElements;
       this._tree = new Array(this._size + 1).fill(0);
@@ -97,6 +97,20 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -168,6 +182,20 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -239,6 +267,20 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -310,6 +352,20 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -379,6 +435,20 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -456,6 +526,20 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -513,6 +597,13 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -579,6 +670,13 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -665,10 +763,10 @@ export class BinaryIndexedTree implements Iterable<number> {
 
   protected _checkIndex(index: number): void {
     if (!Number.isInteger(index)) {
-      throw new TypeError(ERR.invalidIndex('BinaryIndexedTree'));
+      raise(TypeError, ERR.invalidIndex('BinaryIndexedTree'));
     }
     if (index < 0 || index >= this._size) {
-      throw new RangeError(ERR.indexOutOfRange(index, 0, this._size - 1, 'BinaryIndexedTree'));
+      raise(RangeError, ERR.indexOutOfRange(index, 0, this._size - 1, 'BinaryIndexedTree'));
     }
   }