binary-tree-typed 2.4.5 → 2.5.1

package/package.json

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

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,5 +1,4 @@
 import type { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';
-import { ERR } from '../../common';
 
 /**
  * Base class that makes a data structure iterable and provides common
@@ -26,7 +25,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(ERR.notAFunction('toElementFn'));
+      else if (toElementFn) throw new TypeError('toElementFn must be a function type');
     }
   }
 
@@ -36,7 +35,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
    * @remarks
    * Time O(1), Space O(1).
    */
-  protected readonly _toElementFn?: (rawElement: R) => E;
+  protected _toElementFn?: (rawElement: R) => E;
 
   /**
    * Exposes the current `toElementFn`, if configured.
@@ -225,12 +224,12 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
       acc = initialValue as U;
     } else {
       const first = iter.next();
-      if (first.done) throw new TypeError(ERR.reduceEmpty());
+      if (first.done) throw new TypeError('Reduce of empty structure with no initial value');
       acc = first.value as unknown as U;
       index = 1;
     }
 
-    for (const value of iter) {
+    for (const value of iter as unknown as Iterable<E>) {
       acc = callbackfn(acc, value, index++, this);
     }
     return acc;

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

@@ -123,16 +123,12 @@ export class AVLTreeNode<K = any, V = any> {
    *
    * @returns The node's color.
    */
+  /* istanbul ignore next -- inherited field, used by RedBlackTree subclass */  /* istanbul ignore next -- inherited field, not used by AVLTree */
   get color(): RBTNColor {
     return this._color;
   }
 
-  /**
-   * Sets the color of the node.
-   * @remarks Time O(1), Space O(1)
-   *
-   * @param value - The new color.
-   */
+  /* istanbul ignore next -- inherited field, not used by AVLTree */
   set color(value: RBTNColor) {
     this._color = value;
   }
@@ -145,16 +141,12 @@ export class AVLTreeNode<K = any, V = any> {
    *
    * @returns The subtree node count.
    */
+  /* istanbul ignore next -- inherited field, not used by AVLTree */
   get count(): number {
     return this._count;
   }
 
-  /**
-   * Sets the count of nodes in the subtree.
-   * @remarks Time O(1), Space O(1)
-   *
-   * @param value - The new count.
-   */
+  /* istanbul ignore next -- inherited field, not used by AVLTree */
   set count(value: number) {
     this._count = value;
   }
@@ -176,6 +168,7 @@ export class AVLTreeNode<K = any, V = any> {
       return this.left || this.right ? 'ROOT_RIGHT' : 'RIGHT';
     }
 
+    /* istanbul ignore next -- defensive: unreachable if tree structure is correct */
     return 'MAL_NODE';
   }
 }
@@ -197,28 +190,6 @@ export class AVLTreeNode<K = any, V = any> {
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
  *
  * @example
- * // basic AVLTree creation and add operation
- *  // Create a simple AVLTree with initial values
- *     const tree = new AVLTree([5, 2, 8, 1, 9]);
- *
- *     tree.print();
- *     //   _2___
- *     //  /     \
- *     //  1    _8_
- *     //      /   \
- *     //      5   9
- *
- *     // Verify the tree maintains sorted order
- *     console.log([...tree.keys()]); // [1, 2, 5, 8, 9];
- *
- *     // Check size
- *     console.log(tree.size); // 5;
- *
- *     // Add a new element
- *     tree.set(3);
- *     console.log(tree.size); // 6;
- *     console.log([...tree.keys()]); // [1, 2, 3, 5, 8, 9];
- * @example
  * // AVLTree has and get operations
  *  const tree = new AVLTree<number>([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
  *
@@ -233,23 +204,6 @@ export class AVLTreeNode<K = any, V = any> {
  *     // Verify tree is balanced
  *     console.log(tree.isAVLBalanced()); // true;
  * @example
- * // AVLTree delete and balance verification
- *  const tree = new AVLTree([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
- *
- *     // Delete an element
- *     tree.delete(10);
- *     console.log(tree.has(10)); // false;
- *
- *     // Tree should remain balanced after deletion
- *     console.log(tree.isAVLBalanced()); // true;
- *
- *     // Size decreased
- *     console.log(tree.size); // 15;
- *
- *     // Remaining elements are still sorted
- *     const keys = [...tree.keys()];
- *     console.log(keys); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16];
- * @example
  * // AVLTree for university ranking system with strict balance
  *  interface University {
  *       name: string;
@@ -406,6 +360,132 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    * @param keyNodeOrEntry - The key, node, or entry to set.
    * @param [value] - The value, if providing just a key.
    * @returns True if the addition was successful, false otherwise.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Set a key-value pair
+ *  const avl = new AVLTree<number, string>();
+ *     avl.set(1, 'one');
+ *     avl.set(2, 'two');
+ *     console.log(avl.get(1)); // 'one';
    */
   override set(
     keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
@@ -424,6 +504,108 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    *
    * @param keyNodeOrEntry - The node to delete.
    * @returns An array containing deletion results.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove nodes and verify structure
+ *  const avl = new AVLTree<number>([5, 3, 7, 1, 4, 6, 8]);
+ *     avl.delete(3);
+ *     console.log(avl.has(3)); // false;
+ *     console.log(avl.size); // 6;
    */
   override delete(
     keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
@@ -445,6 +627,68 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    *
    * @param [iterationType=this.iterationType] - The traversal method for the initial node export.
    * @returns True if successful, false if the tree was empty.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Rebalance the tree
+ *  const avl = new AVLTree<number>();
+ *     // Insert in sorted order (worst case for BST)
+ *     for (let i = 1; i <= 7; i++) avl.add(i);
+ *     console.log(avl.isAVLBalanced()); // false;
+ *     avl.perfectlyBalance();
+ *     console.log(avl.isAVLBalanced()); // true;
    */
   override perfectlyBalance(iterationType: IterationType = this.iterationType): boolean {
     const nodes = this.dfs(node => node, 'IN', false, this._root, iterationType);
@@ -486,6 +730,96 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    * @param [options] - Options for the new AVLTree.
    * @param [thisArg] - `this` context for the callback.
    * @returns A new, mapped AVLTree.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Transform to new tree
+ *  const avl = new AVLTree<number, number>([[1, 10], [2, 20], [3, 30]]);
+ *     const doubled = avl.map((value, key) => [key, (value ?? 0) * 2] as [number, number]);
+ *     console.log([...doubled.values()]); // [20, 40, 60];
    */
   override map<MK = K, MV = V, MR = any>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
@@ -574,6 +908,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
 
       return destNodeEnsured;
     }
+    /* istanbul ignore next -- defensive: srcNode/destNode are always valid when called internally */
     return undefined;
   }