binary-tree-typed 2.5.0 → 2.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "binary-tree-typed",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "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.0"
+    "data-structure-typed": "^2.5.2"
   }
 }

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/index.ts

@@ -1,2 +1,3 @@
 export * from './iterable-entry-base';
 export * from './iterable-element-base';
+export * from './linear-base';

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/base/iterable-entry-base.ts

@@ -19,7 +19,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * @returns Iterator of `[K, V]`.
    * @remarks Time O(n) to iterate, Space O(1)
    */
-  *[Symbol.iterator](...args: any[]): IterableIterator<[K, V]> {
+  *[Symbol.iterator](...args: unknown[]): IterableIterator<[K, V]> {
     yield* this._getIterator(...args);
   }
 
@@ -63,7 +63,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * @returns `true` if all pass; otherwise `false`.
    * @remarks Time O(n), Space O(1)
    */
-  every(predicate: EntryCallback<K, V, boolean>, thisArg?: any): boolean {
+  every(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): boolean {
     let index = 0;
     for (const item of this) {
       if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
@@ -80,7 +80,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * @returns `true` if any passes; otherwise `false`.
    * @remarks Time O(n), Space O(1)
    */
-  some(predicate: EntryCallback<K, V, boolean>, thisArg?: any): boolean {
+  some(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): boolean {
     let index = 0;
     for (const item of this) {
       if (predicate.call(thisArg, item[1], item[0], index++, this)) {
@@ -96,7 +96,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * @param thisArg - Optional `this` for callback.
    * @remarks Time O(n), Space O(1)
    */
-  forEach(callbackfn: EntryCallback<K, V, void>, thisArg?: any): void {
+  forEach(callbackfn: EntryCallback<K, V, void>, thisArg?: unknown): void {
     let index = 0;
     for (const item of this) {
       const [key, value] = item;
@@ -111,7 +111,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * @returns Matching `[key, value]` or `undefined`.
    * @remarks Time O(n), Space O(1)
    */
-  find(callbackfn: EntryCallback<K, V, boolean>, thisArg?: any): [K, V] | undefined {
+  find(callbackfn: EntryCallback<K, V, boolean>, thisArg?: unknown): [K, V] | undefined {
     let index = 0;
     for (const item of this) {
       const [key, value] = item;
@@ -228,19 +228,19 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * Map entries using an implementation-specific strategy.
    * @remarks Time O(n), Space O(n)
    */
-  abstract map(...args: any[]): any;
+  abstract map(...args: unknown[]): unknown;
 
   /**
    * Filter entries and return the same-species structure.
    * @returns A new instance of the same concrete class (`this` type).
    * @remarks Time O(n), Space O(n)
    */
-  abstract filter(...args: any[]): this;
+  abstract filter(...args: unknown[]): this;
 
   /**
    * Underlying iterator for the default iteration protocol.
    * @returns Iterator of `[K, V]`.
    * @remarks Time O(n), Space O(1)
    */
-  protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
+  protected abstract _getIterator(...args: unknown[]): IterableIterator<[K, V]>;
 }

package/src/data-structures/base/linear-base.ts

@@ -148,7 +148,7 @@ export abstract class LinearBase<
    * @returns Index or `-1`.
    * @remarks Time O(n), Space O(1)
    */
-  findIndex(predicate: ElementCallback<E, R, boolean>, thisArg?: any): number {
+  findIndex(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): number {
     for (let i = 0; i < this.length; i++) {
       const item = this.at(i);
       if (item !== undefined && predicate.call(thisArg, item, i, this)) return i;
@@ -389,7 +389,7 @@ export abstract class LinearBase<
    * @returns Iterator of elements from tail to head.
    * @remarks Time O(n), Space O(1)
    */
-  protected abstract _getReverseIterator(...args: any[]): IterableIterator<E>;
+  protected abstract _getReverseIterator(...args: unknown[]): IterableIterator<E>;
 }
 
 /**
@@ -621,7 +621,7 @@ export abstract class LinearLinkedBase<
    * @returns Iterator over nodes.
    * @remarks Time O(n), Space O(1)
    */
-  protected abstract _getNodeIterator(...args: any[]): IterableIterator<NODE>;
+  protected abstract _getNodeIterator(...args: unknown[]): IterableIterator<NODE>;
 
   /**
    * Get previous node of a given node.

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

@@ -375,6 +375,102 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -432,6 +528,78 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -492,6 +660,54 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Rebalance the tree
  *  const avl = new AVLTree<number>();
@@ -561,6 +777,78 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
     * @example
@@ -718,6 +1006,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);
   }
 
   /**
@@ -770,6 +1060,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);
   }
 
   /**
@@ -809,6 +1102,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);
   }
 
   /**
@@ -860,6 +1155,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);
   }
 
   /**
@@ -878,6 +1176,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)) {