tree-multimap-typed 2.4.5 → 2.5.1

package/dist/types/data-structures/base/index.d.ts

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

package/dist/types/data-structures/base/iterable-element-base.d.ts

@@ -27,7 +27,7 @@ export declare 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.
      *

package/dist/types/data-structures/base/iterable-entry-base.d.ts

@@ -17,7 +17,7 @@ export declare 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]>;
     /**
      * Iterate over `[key, value]` pairs (may yield `undefined` values).
      * @returns Iterator of `[K, V | undefined]`.
@@ -43,7 +43,7 @@ export declare 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;
     /**
      * Test whether any entry satisfies the predicate.
      * @param predicate - `(key, value, index, self) => boolean`.
@@ -51,14 +51,14 @@ export declare 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;
     /**
      * Visit each entry, left-to-right.
      * @param callbackfn - `(key, value, index, self) => void`.
      * @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;
     /**
      * Find the first entry that matches a predicate.
      * @param callbackfn - `(key, value, index, self) => boolean`.
@@ -66,7 +66,7 @@ export declare 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;
     /**
      * Whether the given key exists.
      * @param key - Key to test.
@@ -134,17 +134,17 @@ export declare 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/dist/types/data-structures/base/linear-base.d.ts

@@ -89,7 +89,7 @@ export declare abstract class LinearBase<E, R = any, NODE extends LinkedListNode
      * @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;
     /**
      * Concatenate elements and/or containers.
      * @param items - Elements or other containers.
@@ -228,7 +228,7 @@ export declare abstract class LinearBase<E, R = any, NODE extends LinkedListNode
      * @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>;
 }
 /**
  * Linked-list specialized linear container.
@@ -324,7 +324,7 @@ export declare abstract class LinearLinkedBase<E, R = any, NODE extends LinkedLi
      * @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.
      * @param node - Current node.

package/dist/types/data-structures/binary-tree/avl-tree.d.ts

@@ -80,12 +80,6 @@ export declare class AVLTreeNode<K = any, V = any> {
      * @returns The node's color.
      */
     get color(): RBTNColor;
-    /**
-     * Sets the color of the node.
-     * @remarks Time O(1), Space O(1)
-     *
-     * @param value - The new color.
-     */
     set color(value: RBTNColor);
     _count: number;
     /**
@@ -95,12 +89,6 @@ export declare class AVLTreeNode<K = any, V = any> {
      * @returns The subtree node count.
      */
     get count(): number;
-    /**
-     * Sets the count of nodes in the subtree.
-     * @remarks Time O(1), Space O(1)
-     *
-     * @param value - The new count.
-     */
     set count(value: number);
     /**
      * Gets the position of the node relative to its parent.
@@ -127,28 +115,6 @@ export declare 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]);
  *
@@ -163,23 +129,6 @@ export declare 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;
@@ -318,6 +267,132 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      * @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';
      */
     set(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
     /**
@@ -326,6 +401,108 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      *
      * @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;
      */
     delete(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[];
     /**
@@ -335,6 +512,68 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      *
      * @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;
      */
     perfectlyBalance(iterationType?: IterationType): boolean;
     /**
@@ -348,6 +587,96 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      * @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];
      */
     map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): AVLTree<MK, MV, MR>;
     /**