doubly-linked-list-typed 1.53.9 → 1.54.0

package/dist/data-structures/binary-tree/tree-multi-map.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback, IterationType, RBTNColor, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
@@ -22,20 +22,8 @@ export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMa
      * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
      */
     constructor(key: K, value?: V, count?: number, color?: RBTNColor);
-    protected _count: number;
-    /**
-     * The function returns the value of the private variable _count.
-     * @returns The count property of the object, which is of type number.
-     */
-    get count(): number;
-    /**
-     * The above function sets the value of the count property.
-     * @param {number} value - The value parameter is of type number, which means it can accept any
-     * numeric value.
-     */
-    set count(value: number);
 }
-export declare class TreeMultiMap<K = any, V = any, R = object, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>> extends RedBlackTree<K, V, R, NODE> implements IBinaryTree<K, V, R, NODE> {
+export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE> = TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMapNested<K, V, R, MK, MV, MR, NODE>>> extends RedBlackTree<K, V, R, MK, MV, MR, NODE, TREE> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
      * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
@@ -83,7 +71,20 @@ export declare class TreeMultiMap<K = any, V = any, R = object, NODE extends Tre
      * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
-    createTree(options?: TreeMultiMapOptions<K, V, R>): TreeMultiMap<K, V, R, NODE>;
+    createTree(options?: TreeMultiMapOptions<K, V, R>): TREE;
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
+     * node based on the input.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {V} [value] - The `value` parameter is an optional value that represents the value
+     * associated with the key in the node. It is used when creating a new node or updating the value of
+     * an existing node.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
+     * @returns either a NODE object or undefined.
+     */
+    protected _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
      * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
@@ -154,36 +155,7 @@ export declare class TreeMultiMap<K = any, V = any, R = object, NODE extends Tre
      * The function overrides the clone method to create a deep copy of a tree object.
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
-    clone(): TreeMultiMap<K, V, R, NODE>;
-    /**
-     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
-     * modified entries based on a provided callback.
-     * @param callback - The `callback` parameter is a function that will be called for each entry in the
-     * map. It takes four arguments:
-     * @param [options] - The `options` parameter in the `override map` function is of type
-     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
-     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
-     * include things like
-     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-     * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) for the callback function when it is called within the `map` function. This
-     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
-     * by the provided callback function.
-     */
-    map<MK, MV, MR>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: TreeMultiMapOptions<MK, MV, MR>, thisArg?: any): TreeMultiMap<MK, MV, MR, TreeMultiMapNode<MK, MV, TreeMultiMapNodeNested<MK, MV>>>;
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
-     * node based on the input.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that represents the value
-     * associated with the key in the node. It is used when creating a new node or updating the value of
-     * an existing node.
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
-     */
-    protected _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
+    clone(): TREE;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -211,4 +183,20 @@ export declare class TreeMultiMap<K = any, V = any, R = object, NODE extends Tre
      * superclass, which is of type `NODE`.
      */
     protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
+     * modified entries based on a provided callback.
+     * @param callback - The `callback` parameter is a function that will be called for each entry in the
+     * map. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
+     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
+     * include things like
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function when it is called within the `map` function. This
+     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
+     * by the provided callback function.
+     */
+    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: TreeMultiMapOptions<MK, MV, MR>, thisArg?: any): TreeMultiMap<MK, MV, MR>;
 }

package/dist/data-structures/binary-tree/tree-multi-map.js

@@ -17,24 +17,8 @@ class TreeMultiMapNode extends red_black_tree_1.RedBlackTreeNode {
      */
     constructor(key, value, count = 1, color = 'BLACK') {
         super(key, value, color);
-        this._count = 1;
         this.count = count;
     }
-    /**
-     * The function returns the value of the private variable _count.
-     * @returns The count property of the object, which is of type number.
-     */
-    get count() {
-        return this._count;
-    }
-    /**
-     * The above function sets the value of the count property.
-     * @param {number} value - The value parameter is of type number, which means it can accept any
-     * numeric value.
-     */
-    set count(value) {
-        this._count = value;
-    }
 }
 exports.TreeMultiMapNode = TreeMultiMapNode;
 class TreeMultiMap extends red_black_tree_1.RedBlackTree {
@@ -98,10 +82,44 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
-    // @ts-ignore
     createTree(options) {
         return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn }, options));
     }
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
+     * node based on the input.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {V} [value] - The `value` parameter is an optional value that represents the value
+     * associated with the key in the node. It is used when creating a new node or updating the value of
+     * an existing node.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
+     * @returns either a NODE object or undefined.
+     */
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
+        if (keyNodeEntryOrRaw === undefined || keyNodeEntryOrRaw === null)
+            return [undefined, undefined];
+        if (this.isNode(keyNodeEntryOrRaw))
+            return [keyNodeEntryOrRaw, value];
+        if (this.isEntry(keyNodeEntryOrRaw)) {
+            const [key, entryValue] = keyNodeEntryOrRaw;
+            if (key === undefined || key === null)
+                return [undefined, undefined];
+            const finalValue = value !== null && value !== void 0 ? value : entryValue;
+            if (this.isKey(key))
+                return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
+        }
+        if (this.isRaw(keyNodeEntryOrRaw)) {
+            const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+            const finalValue = value !== null && value !== void 0 ? value : entryValue;
+            if (this.isKey(key))
+                return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
+        }
+        if (this.isKey(keyNodeEntryOrRaw))
+            return [this.createNode(keyNodeEntryOrRaw, value, 'BLACK', count), value];
+        return [undefined, undefined];
+    }
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
      * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
@@ -170,10 +188,13 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
         let originalColor = nodeToDelete.color;
         let replacementNode;
         if (!this.isRealNode(nodeToDelete.left)) {
-            replacementNode = nodeToDelete.right;
+            if (nodeToDelete.right !== null)
+                replacementNode = nodeToDelete.right;
             if (ignoreCount || nodeToDelete.count <= 1) {
-                this._transplant(nodeToDelete, nodeToDelete.right);
-                this._count -= nodeToDelete.count;
+                if (nodeToDelete.right !== null) {
+                    this._transplant(nodeToDelete, nodeToDelete.right);
+                    this._count -= nodeToDelete.count;
+                }
             }
             else {
                 nodeToDelete.count--;
@@ -199,7 +220,8 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
             const successor = this.getLeftMost(node => node, nodeToDelete.right);
             if (successor) {
                 originalColor = successor.color;
-                replacementNode = successor.right;
+                if (successor.right !== null)
+                    replacementNode = successor.right;
                 if (successor.parent === nodeToDelete) {
                     if (this.isRealNode(replacementNode)) {
                         replacementNode.parent = successor;
@@ -207,8 +229,10 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
                 }
                 else {
                     if (ignoreCount || nodeToDelete.count <= 1) {
-                        this._transplant(successor, successor.right);
-                        this._count -= nodeToDelete.count;
+                        if (successor.right !== null) {
+                            this._transplant(successor, successor.right);
+                            this._count -= nodeToDelete.count;
+                        }
                     }
                     else {
                         nodeToDelete.count--;
@@ -319,7 +343,6 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      * The function overrides the clone method to create a deep copy of a tree object.
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
-    // @ts-ignore
     clone() {
         const cloned = this.createTree();
         this.bfs(node => cloned.add(node.key, undefined, node.count));
@@ -327,65 +350,6 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
             cloned._store = this._store;
         return cloned;
     }
-    /**
-     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
-     * modified entries based on a provided callback.
-     * @param callback - The `callback` parameter is a function that will be called for each entry in the
-     * map. It takes four arguments:
-     * @param [options] - The `options` parameter in the `override map` function is of type
-     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
-     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
-     * include things like
-     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-     * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) for the callback function when it is called within the `map` function. This
-     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
-     * by the provided callback function.
-     */
-    // @ts-ignore
-    map(callback, options, thisArg) {
-        const newTree = new TreeMultiMap([], options);
-        let index = 0;
-        for (const [key, value] of this) {
-            newTree.add(callback.call(thisArg, key, value, index++, this));
-        }
-        return newTree;
-    }
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
-     * node based on the input.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that represents the value
-     * associated with the key in the node. It is used when creating a new node or updating the value of
-     * an existing node.
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
-     */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
-        if (keyNodeEntryOrRaw === undefined || keyNodeEntryOrRaw === null)
-            return [undefined, undefined];
-        if (this.isNode(keyNodeEntryOrRaw))
-            return [keyNodeEntryOrRaw, value];
-        if (this.isEntry(keyNodeEntryOrRaw)) {
-            const [key, entryValue] = keyNodeEntryOrRaw;
-            if (key === undefined || key === null)
-                return [undefined, undefined];
-            const finalValue = value !== null && value !== void 0 ? value : entryValue;
-            if (this.isKey(key))
-                return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
-        }
-        if (this.isRaw(keyNodeEntryOrRaw)) {
-            const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-            const finalValue = value !== null && value !== void 0 ? value : entryValue;
-            if (this.isKey(key))
-                return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
-        }
-        if (this.isKey(keyNodeEntryOrRaw))
-            return [this.createNode(keyNodeEntryOrRaw, value, 'BLACK', count), value];
-        return [undefined, undefined];
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -438,5 +402,28 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
         newNode.count = oldNode.count + newNode.count;
         return super._replaceNode(oldNode, newNode);
     }
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
+     * modified entries based on a provided callback.
+     * @param callback - The `callback` parameter is a function that will be called for each entry in the
+     * map. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
+     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
+     * include things like
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function when it is called within the `map` function. This
+     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
+     * by the provided callback function.
+     */
+    map(callback, options, thisArg) {
+        const newTree = new TreeMultiMap([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
+        }
+        return newTree;
+    }
 }
 exports.TreeMultiMap = TreeMultiMap;

package/dist/interfaces/binary-tree.d.ts

@@ -1,7 +1,8 @@
-import { BinaryTreeNode } from '../data-structures';
-import type { BinaryTreeDeleteResult, BinaryTreeNodeNested, BTNRep, NodePredicate } from '../types';
-export interface IBinaryTree<K = any, V = any, R = object, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>> {
+import { BinaryTree, BinaryTreeNode } from '../data-structures';
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNRep, NodePredicate } from '../types';
+export interface IBinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = object, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, R, MK, MV, MR, NODE, TREE> = BinaryTreeNested<K, V, R, MK, MV, MR, NODE>> {
     createNode(key: K, value?: NODE['value']): NODE;
+    createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
     add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, NODE>, value?: V, count?: number): boolean;
     addMany(nodes: Iterable<BTNRep<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
     delete(predicate: R | BTNRep<K, V, NODE> | NodePredicate<NODE>): BinaryTreeDeleteResult<NODE>[];

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

@@ -1,4 +1,5 @@
-import { AVLTreeMultiMapNode } from '../../../data-structures';
+import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../data-structures';
 import type { AVLTreeOptions } from './avl-tree';
-export type AVLTreeMultiMapNodeNested<K, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>>>>>>>>;
+export type AVLTreeMultiMapNodeNested<K, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>;
+export type AVLTreeMultiMapNested<K, V, R, MK, MV, MR, NODE extends AVLTreeMultiMapNode<K, V, NODE>> = AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, any>>>;
 export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

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

@@ -1,4 +1,5 @@
-import { AVLTreeNode } from '../../../data-structures';
+import { AVLTree, AVLTreeNode } from '../../../data-structures';
 import { BSTOptions } from './bst';
-export type AVLTreeNodeNested<K, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, any>>>>>>>>>>;
+export type AVLTreeNodeNested<K, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, any>>>;
+export type AVLTreeNested<K, V, R, MK, MV, MR, NODE extends AVLTreeNode<K, V, NODE>> = AVLTree<K, V, R, MK, MV, MR, NODE, AVLTree<K, V, R, MK, MV, MR, NODE, AVLTree<K, V, R, MK, MV, MR, NODE, any>>>;
 export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -1,7 +1,8 @@
-import { BinaryTreeNode } from '../../../data-structures';
+import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
 import { IterationType, OptValue } from '../../common';
 import { DFSOperation } from '../../../common';
-export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>;
+export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>;
+export type BinaryTreeNested<K, V, R, MK, MV, MR, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, MK, MV, MR, NODE, BinaryTree<K, V, R, MK, MV, MR, NODE, BinaryTree<K, V, R, MK, MV, MR, NODE, any>>>;
 export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
 export type BinaryTreeOptions<K, V, R> = {
     iterationType?: IterationType;

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

@@ -1,7 +1,8 @@
-import { BSTNode } from '../../../data-structures';
+import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
 import { Comparable } from '../../utils';
-export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>;
+export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>;
+export type BSTNested<K, V, R, MK, MV, MR, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, MK, MV, MR, NODE, BST<K, V, R, MK, MV, MR, NODE, BST<K, V, R, MK, MV, MR, NODE, any>>>;
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
     specifyComparable?: (key: K) => Comparable;
     isReverse?: boolean;

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

@@ -1,5 +1,6 @@
-import { RedBlackTreeNode } from '../../../data-structures';
-import type { BSTOptions } from './bst';
+import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
+import type { BSTOptions } from "./bst";
 export type RBTNColor = 'RED' | 'BLACK';
-export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>;
-export type RedBlackTreeOptions<K, V, R> = Omit<BSTOptions<K, V, R>, 'isReverse'> & {};
+export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>;
+export type RedBlackTreeNested<K, V, R, MK, MV, MR, NODE extends RedBlackTreeNode<K, V, NODE>> = RedBlackTree<K, V, R, MK, MV, MR, NODE, RedBlackTree<K, V, R, MK, MV, MR, NODE, RedBlackTree<K, V, R, MK, MV, MR, NODE, any>>>;
+export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -1,4 +1,5 @@
-import { TreeMultiMapNode } from '../../../data-structures';
+import { TreeMultiMap, TreeMultiMapNode } from '../../../data-structures';
 import type { RedBlackTreeOptions } from './rb-tree';
-export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>;
+export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>;
+export type TreeMultiMapNested<K, V, R, MK, MV, MR, NODE extends TreeMultiMapNode<K, V, NODE>> = TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMap<K, V, R, MK, MV, MR, NODE, any>>>;
 export type TreeMultiMapOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doubly-linked-list-typed",
-  "version": "1.53.9",
+  "version": "1.54.0",
   "description": "Doubly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -64,6 +64,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.53.9"
+    "data-structure-typed": "^1.54.0"
   }
 }

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

@@ -6,6 +6,7 @@
  * @license MIT License
  */
 import type {
+  AVLTreeMultiMapNested,
   AVLTreeMultiMapNodeNested,
   AVLTreeMultiMapOptions,
   BinaryTreeDeleteResult,
@@ -36,25 +37,6 @@ export class AVLTreeMultiMapNode<
     super(key, value);
     this.count = count;
   }
-
-  protected _count: number = 1;
-
-  /**
-   * The function returns the value of the protected variable _count.
-   * @returns The count property of the object, which is of type number.
-   */
-  get count(): number {
-    return this._count;
-  }
-
-  /**
-   * The above function sets the value of the count property.
-   * @param {number} value - The value parameter is of type number, which means it can accept any
-   * numeric value.
-   */
-  set count(value: number) {
-    this._count = value;
-  }
 }
 
 /**
@@ -64,10 +46,23 @@ export class AVLTreeMultiMap<
     K = any,
     V = any,
     R = object,
-    NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>
+    MK = any,
+    MV = any,
+    MR = object,
+    NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>,
+    TREE extends AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE> = AVLTreeMultiMap<
+      K,
+      V,
+      R,
+      MK,
+      MV,
+      MR,
+      NODE,
+      AVLTreeMultiMapNested<K, V, R, MK, MV, MR, NODE>
+    >
   >
-  extends AVLTree<K, V, R, NODE>
-  implements IBinaryTree<K, V, R, NODE>
+  extends AVLTree<K, V, R, MK, MV, MR, NODE, TREE>
+  implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE>
 {
   /**
    * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
@@ -132,16 +127,15 @@ export class AVLTreeMultiMap<
    * @returns a new instance of the AVLTreeMultiMap class, with the specified options, as a TREE
    * object.
    */
-  // @ts-ignore
-  override createTree(options?: AVLTreeMultiMapOptions<K, V, R>) {
-    return new AVLTreeMultiMap<K, V, R, NODE>([], {
+  override createTree(options?: AVLTreeMultiMapOptions<K, V, R>): TREE {
+    return new AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
       specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
       ...options
-    });
+    }) as TREE;
   }
 
   /**
@@ -220,7 +214,7 @@ export class AVLTreeMultiMap<
     } else {
       if (!curr.left) {
         if (!parent) {
-          if (curr.right !== undefined) this._setRoot(curr.right);
+          if (curr.right !== undefined && curr.right !== null) this._setRoot(curr.right);
         } else {
           const { familyPosition: fp } = curr;
           if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
@@ -330,8 +324,7 @@ export class AVLTreeMultiMap<
    * The function overrides the clone method to create a deep copy of a tree object.
    * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
    */
-  // @ts-ignore
-  override clone() {
+  override clone(): TREE {
     const cloned = this.createTree();
     if (this._isMapMode) this.bfs(node => cloned.add(node.key, undefined, node.count));
     else this.bfs(node => cloned.add(node.key, node.value, node.count));
@@ -357,12 +350,11 @@ export class AVLTreeMultiMap<
    * `callback` function along with the index and the original tree itself. The transformed entries are
    * then added to the new `AVLTreeMultiMap` instance, which is returned at the end.
    */
-  // @ts-ignore
   override map<MK, MV, MR>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
     options?: AVLTreeMultiMapOptions<MK, MV, MR>,
     thisArg?: any
-  ) {
+  ): AVLTreeMultiMap<MK, MV, MR> {
     const newTree = new AVLTreeMultiMap<MK, MV, MR>([], options);
     let index = 0;
     for (const [key, value] of this) {