directed-graph-typed 1.52.8 → 1.53.0

package/dist/data-structures/binary-tree/rb-tree.js

@@ -37,7 +37,7 @@ exports.RedBlackTreeNode = RedBlackTreeNode;
 class RedBlackTree extends bst_1.BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
      * initialize the RBTree with the provided elements.
      * @param [options] - The `options` parameter is an optional object that can be passed to the
@@ -45,11 +45,11 @@ class RedBlackTree extends bst_1.BST {
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
      * depend on the implementation
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
         this._root = this.NIL;
-        if (keysOrNodesOrEntriesOrRaws) {
-            this.addMany(keysOrNodesOrEntriesOrRaws);
+        if (keysNodesEntriesOrRaws) {
+            this.addMany(keysNodesEntriesOrRaws);
         }
     }
     /**
@@ -83,20 +83,20 @@ class RedBlackTree extends bst_1.BST {
      * @returns a new instance of a RedBlackTree object.
      */
     createTree(options) {
-        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
+        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `RedBlackTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-        return keyOrNodeOrEntryOrRaw instanceof RedBlackTreeNode;
+    isNode(keyNodeEntryOrRaw) {
+        return keyNodeEntryOrRaw instanceof RedBlackTreeNode;
     }
     // /**
     //  * Time Complexity: O(1)
@@ -107,29 +107,29 @@ class RedBlackTree extends bst_1.BST {
     //  * Time Complexity: O(1)
     //  * Space Complexity: O(1)
     //  *
-    //  * The function `keyValueOrEntryOrRawElementToNode` takes a key, value, or entry and returns a node if it is
+    //  * The function `keyValueNodeEntryRawToNodeAndValue` takes a key, value, or entry and returns a node if it is
     //  * valid, otherwise it returns undefined.
-    //  * @param {BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRaw - The key, value, or entry to convert.
-    //  * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntryOrRaw` is a key).
+    //  * @param {BTNRep<K, V, NODE>} keyNodeEntryOrRaw - The key, value, or entry to convert.
+    //  * @param {V} [value] - The value associated with the key (if `keyNodeEntryOrRaw` is a key).
     //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
     //  */
-    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): NODE | undefined {
+    // override keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): NODE | undefined {
     //
-    //   if (keyOrNodeOrEntryOrRaw === null || keyOrNodeOrEntryOrRaw === undefined) return;
-    //   if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
+    //   if (keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === undefined) return;
+    //   if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw;
     //
     //   if (this._toEntryFn) {
-    //     const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw as R);
-    //     if (this.isKey(key)) return this.createNode(key, entryValue ?? value, 'RED');
+    //     const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
+    //     if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'RED');
     //   }
     //
-    //   if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-    //     const [key, value] = keyOrNodeOrEntryOrRaw;
+    //   if (this.isEntry(keyNodeEntryOrRaw)) {
+    //     const [key, value] = keyNodeEntryOrRaw;
     //     if (key === undefined || key === null) return;
     //     else return  this.createNode(key, value, 'RED');
     //   }
     //
-    //   if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, 'RED');
+    //   if (this.isKey(keyNodeEntryOrRaw)) return this.createNode(keyNodeEntryOrRaw, value, 'RED');
     //
     //   return ;
     // }
@@ -150,8 +150,8 @@ class RedBlackTree extends bst_1.BST {
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key in the data structure. It represents the value that you want to add or update in the data
      * structure.
@@ -159,8 +159,8 @@ class RedBlackTree extends bst_1.BST {
      * the method returns true. If the node already exists and its value is updated, the method also
      * returns true. If the node cannot be added or updated, the method returns false.
      */
-    add(keyOrNodeOrEntryOrRaw, value) {
-        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
+    add(keyNodeEntryOrRaw, value) {
+        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (!this.isRealNode(newNode))
             return false;
         const insertStatus = this._insert(newNode);
@@ -172,6 +172,8 @@ class RedBlackTree extends bst_1.BST {
             else {
                 return false;
             }
+            if (this._isMapMode)
+                this._setValue(newNode.key, newValue);
             this._size++;
             return true;
         }
@@ -184,7 +186,7 @@ class RedBlackTree extends bst_1.BST {
      *
      * The function overrides the delete method in a binary tree data structure to remove a node based on
      * a given predicate and maintain the binary search tree properties.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
      * parameter in the `override delete` method is used to specify the condition or key based on which a
      * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
      * function that determines which node(s) should be deleted.
@@ -192,15 +194,15 @@ class RedBlackTree extends bst_1.BST {
      * objects. Each object in the array contains information about the deleted node and whether
      * balancing is needed.
      */
-    delete(predicate) {
-        if (predicate === null)
+    delete(keyNodeEntryOrRaw) {
+        if (keyNodeEntryOrRaw === null)
             return [];
         const results = [];
         let nodeToDelete;
-        if (this._isPredicated(predicate))
-            nodeToDelete = this.getNode(predicate);
+        if (this._isPredicate(keyNodeEntryOrRaw))
+            nodeToDelete = this.getNode(keyNodeEntryOrRaw);
         else
-            nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
+            nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
         if (!nodeToDelete) {
             return results;
         }
@@ -239,6 +241,8 @@ class RedBlackTree extends bst_1.BST {
                 successor.color = nodeToDelete.color;
             }
         }
+        if (this._isMapMode)
+            this._store.delete(nodeToDelete.key);
         this._size--;
         // If the original color was black, fix the tree
         if (originalColor === 'BLACK') {

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, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, BTNPredicate, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions, BTNEntry } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
@@ -35,17 +35,17 @@ export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMa
      */
     set count(value: number);
 }
-export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>> extends RedBlackTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class TreeMultiMap<K = any, V = any, R = object, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>> extends RedBlackTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
-     * @param keysOrNodesOrEntriesOrRaws - The parameter `keysOrNodesOrEntriesOrRaws` is an
+     * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
      * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
      * TreeMultiMap with initial data.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
      * `compareValues`, which are functions used to compare keys and values respectively.
      */
-    constructor(keysOrNodesOrEntriesOrRaws?: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: TreeMultiMapOptions<K, V, R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<BTNRep<K, V, NODE>>, options?: TreeMultiMapOptions<K, V, R>);
     protected _count: number;
     /**
      * The function calculates the sum of the count property of all nodes in a tree structure.
@@ -85,10 +85,10 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      */
     createTree(options?: TreeMultiMapOptions<K, V, R>): TREE;
     /**
-     * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
+     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @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.
@@ -96,23 +96,23 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * 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.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V, count?: number): NODE | undefined;
+    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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `TreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE;
+    isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function overrides the add method of a class and adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-     * `keyOrNodeOrEntryOrRaw` parameter can accept one of the following types:
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
@@ -121,24 +121,23 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * @returns The method is returning a boolean value. It returns true if the addition of the new node
      * was successful, and false otherwise.
      */
-    add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V, count?: number): boolean;
+    add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
      * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `predicate`
      * parameter in the `delete` method is used to specify the condition or key based on which a node
-     * should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
-     * function.
+     * should be deleted from the binary tree. It can be a key, a node, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
      * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
      * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
      * `ignoreCount` is `false
      * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
      */
-    delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
+    delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -175,15 +174,15 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      *
      * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
      * in a binary search tree.
-     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
      * that will be swapped with the `destNode`. It can be either an instance of the `R` class or an
-     * instance of the `BSTNKeyOrNode<K, NODE>` class.
-     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * instance of the `BSTNOptKeyOrNode<K, NODE>` class.
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
      * node where the properties will be swapped with the source node.
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      * If either `srcNode` or `destNode` is undefined, it returns undefined.
      */
-    protected _swapProperties(srcNode: R | BSTNKeyOrNode<K, NODE>, destNode: R | BSTNKeyOrNode<K, NODE>): NODE | undefined;
+    protected _swapProperties(srcNode: R | BSTNOptKeyOrNode<K, NODE>, destNode: R | BSTNOptKeyOrNode<K, NODE>): NODE | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -40,18 +40,18 @@ exports.TreeMultiMapNode = TreeMultiMapNode;
 class TreeMultiMap extends rb_tree_1.RedBlackTree {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
-     * @param keysOrNodesOrEntriesOrRaws - The parameter `keysOrNodesOrEntriesOrRaws` is an
+     * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
      * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
      * TreeMultiMap with initial data.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
      * `compareValues`, which are functions used to compare keys and values respectively.
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
         this._count = 0;
-        if (keysOrNodesOrEntriesOrRaws)
-            this.addMany(keysOrNodesOrEntriesOrRaws);
+        if (keysNodesEntriesOrRaws)
+            this.addMany(keysNodesEntriesOrRaws);
     }
     // TODO the _count is not accurate after nodes count modified
     /**
@@ -99,13 +99,13 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
     createTree(options) {
-        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
+        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
     }
     /**
-     * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
+     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @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.
@@ -113,36 +113,38 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * 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.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count = 1) {
-        if (keyOrNodeOrEntryOrRaw === undefined || keyOrNodeOrEntryOrRaw === null)
-            return;
-        if (this.isNode(keyOrNodeOrEntryOrRaw))
-            return keyOrNodeOrEntryOrRaw;
-        if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-            const [key, entryValue] = keyOrNodeOrEntryOrRaw;
+    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;
+                return [undefined, undefined];
+            const finalValue = value !== null && value !== void 0 ? value : entryValue;
             if (this.isKey(key))
-                return this.createNode(key, value !== null && value !== void 0 ? value : entryValue, 'BLACK', count);
+                return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
         }
         if (this._toEntryFn) {
-            const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw);
+            const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+            const finalValue = value !== null && value !== void 0 ? value : entryValue;
             if (this.isKey(key))
-                return this.createNode(key, value !== null && value !== void 0 ? value : entryValue, 'BLACK', count);
+                return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
         }
-        if (this.isKey(keyOrNodeOrEntryOrRaw))
-            return this.createNode(keyOrNodeOrEntryOrRaw, value, 'BLACK', count);
-        return;
+        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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `TreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-        return keyOrNodeOrEntryOrRaw instanceof TreeMultiMapNode;
+    isNode(keyNodeEntryOrRaw) {
+        return keyNodeEntryOrRaw instanceof TreeMultiMapNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -150,8 +152,8 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      *
      * The function overrides the add method of a class and adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-     * `keyOrNodeOrEntryOrRaw` parameter can accept one of the following types:
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
@@ -160,10 +162,10 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * @returns The method is returning a boolean value. It returns true if the addition of the new node
      * was successful, and false otherwise.
      */
-    add(keyOrNodeOrEntryOrRaw, value, count = 1) {
-        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count);
+    add(keyNodeEntryOrRaw, value, count = 1) {
+        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
         const orgCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
-        const isSuccessAdded = super.add(newNode);
+        const isSuccessAdded = super.add(newNode, newValue);
         if (isSuccessAdded) {
             this._count += orgCount;
             return true;
@@ -178,25 +180,24 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      *
      * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
      * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `predicate`
      * parameter in the `delete` method is used to specify the condition or key based on which a node
-     * should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
-     * function.
+     * should be deleted from the binary tree. It can be a key, a node, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
      * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
      * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
      * `ignoreCount` is `false
      * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
      */
-    delete(predicate, ignoreCount = false) {
-        if (predicate === null)
+    delete(keyNodeEntryOrRaw, ignoreCount = false) {
+        if (keyNodeEntryOrRaw === null)
             return [];
         const results = [];
         let nodeToDelete;
-        if (this._isPredicated(predicate))
-            nodeToDelete = this.getNode(predicate);
+        if (this._isPredicate(keyNodeEntryOrRaw))
+            nodeToDelete = this.getNode(keyNodeEntryOrRaw);
         else
-            nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
+            nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
         if (!nodeToDelete) {
             return results;
         }
@@ -314,7 +315,10 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.key, midNode.value, midNode.count);
+                if (this._isMapMode)
+                    this.add(midNode.key, undefined, midNode.count);
+                else
+                    this.add(midNode.key, midNode.value, midNode.count);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -330,7 +334,10 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.key, midNode.value, midNode.count);
+                        if (this._isMapMode)
+                            this.add(midNode.key, undefined, midNode.count);
+                        else
+                            this.add(midNode.key, midNode.value, midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -348,7 +355,9 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      */
     clone() {
         const cloned = this.createTree();
-        this.bfs(node => cloned.add(node.key, node.value, node.count));
+        this.bfs(node => cloned.add(node.key, undefined, node.count));
+        if (this._isMapMode)
+            cloned._store = this._store;
         return cloned;
     }
     /**
@@ -357,10 +366,10 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      *
      * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
      * in a binary search tree.
-     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
      * that will be swapped with the `destNode`. It can be either an instance of the `R` class or an
-     * instance of the `BSTNKeyOrNode<K, NODE>` class.
-     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * instance of the `BSTNOptKeyOrNode<K, NODE>` class.
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
      * node where the properties will be swapped with the source node.
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      * If either `srcNode` or `destNode` is undefined, it returns undefined.
@@ -374,11 +383,13 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
             if (tempNode) {
                 tempNode.color = color;
                 destNode.key = srcNode.key;
-                destNode.value = srcNode.value;
+                if (!this._isMapMode)
+                    destNode.value = srcNode.value;
                 destNode.count = srcNode.count;
                 destNode.color = srcNode.color;
                 srcNode.key = tempNode.key;
-                srcNode.value = tempNode.value;
+                if (!this._isMapMode)
+                    srcNode.value = tempNode.value;
                 srcNode.count = tempNode.count;
                 srcNode.color = tempNode.color;
             }

package/dist/data-structures/trie/trie.js

@@ -239,9 +239,9 @@ class Trie extends base_1.IterableElementBase {
      *
      */
     getHeight() {
-        const beginRoot = this.root;
+        const startNode = this.root;
         let maxDepth = 0;
-        if (beginRoot) {
+        if (startNode) {
             const bfs = (node, level) => {
                 if (level > maxDepth) {
                     maxDepth = level;
@@ -253,7 +253,7 @@ class Trie extends base_1.IterableElementBase {
                     }
                 }
             };
-            bfs(beginRoot, 0);
+            bfs(startNode, 0);
         }
         return maxDepth;
     }

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

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

@@ -3,29 +3,29 @@ import { IterationType, OptValue } from '../../common';
 import { DFSOperation } from '../../../constants';
 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, 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, 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, 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, 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 BinaryTreeNested<K, V, R, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
 export type BinaryTreeOptions<K, V, R> = {
     iterationType?: IterationType;
-    toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
+    toEntryFn?: ToEntryFn<K, V, R>;
+    isMapMode?: boolean;
 };
 export type BinaryTreePrintOptions = {
     isShowUndefined?: boolean;
     isShowNull?: boolean;
     isShowRedBlackNIL?: boolean;
 };
-export type OptBTNOrNull<NODE> = NODE | null | undefined;
-export type OptBTNKeyOrNull<K> = K | null | undefined;
-export type BTNEntry<K, V> = [OptBTNKeyOrNull<K>, OptValue<V>];
-export type BTNKeyOrNode<K, NODE> = OptBTNKeyOrNull<K> | NODE;
-export type BTNKeyOrNodeOrEntry<K, V, NODE> = BTNEntry<K, V> | BTNKeyOrNode<K, NODE>;
-export type BTNPureKeyOrNode<K, NODE> = K | NODE;
-export type BTNPureKeyOrNodeOrEntry<K, V, NODE> = [K, OptValue<V>] | BTNPureKeyOrNode<K, NODE>;
+export type OptNodeOrNull<NODE> = NODE | null | undefined;
+export type BTNOptKeyOrNull<K> = K | null | undefined;
+export type BTNEntry<K, V> = [BTNOptKeyOrNull<K>, OptValue<V>];
+export type BTNOptKeyNodeOrNull<K, NODE> = BTNOptKeyOrNull<K> | NODE;
+export type BTNRep<K, V, NODE> = BTNEntry<K, V> | BTNOptKeyNodeOrNull<K, NODE>;
 export type BinaryTreeDeleteResult<NODE> = {
-    deleted: OptBTNOrNull<NODE>;
-    needBalanced: OptBTNOrNull<NODE>;
+    deleted: OptNodeOrNull<NODE>;
+    needBalanced: OptNodeOrNull<NODE>;
 };
-export type BTNCallback<NODE, D = any> = (node: NODE) => D;
-export type BTNPredicate<NODE> = (node: NODE) => boolean;
+export type NodeCallback<NODE, D = any> = (node: NODE) => D;
+export type NodePredicate<NODE> = (node: NODE) => boolean;
 export type DFSStackItem<NODE> = {
     opt: DFSOperation;
-    node: OptBTNOrNull<NODE>;
+    node: OptNodeOrNull<NODE>;
 };

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

@@ -6,6 +6,6 @@ export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R,
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
     comparator?: Comparator<K>;
 };
-export type OptBSTNKey<K> = K | undefined;
-export type OptBSTN<NODE> = NODE | undefined;
-export type BSTNKeyOrNode<K, NODE> = OptBSTNKey<K> | NODE;
+export type BSTNOptKey<K> = K | undefined;
+export type OptNode<NODE> = NODE | undefined;
+export type BSTNOptKeyOrNode<K, NODE> = BSTNOptKey<K> | NODE;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directed-graph-typed",
-  "version": "1.52.8",
+  "version": "1.53.0",
   "description": "Directed Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -147,6 +147,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.52.8"
+    "data-structure-typed": "^1.53.0"
   }
 }