directed-graph-typed 1.52.0 → 1.52.1

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

@@ -11,12 +11,13 @@ import type {
   BSTNodeNested,
   BSTOptions,
   BTNCallback,
+  BTNKeyOrNodeOrEntry,
   BTNPureKeyOrNodeOrEntry,
   Comparator,
   CP,
   DFSOrderPattern,
   IterationType,
-  KeyOrNodeOrEntry
+  OptBSTN
 } from '../../types';
 import { BTNEntry } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
@@ -43,16 +44,16 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
    * The function returns the value of the `_left` property.
    * @returns The `_left` property of the current object is being returned.
    */
-  override get left(): NODE | undefined {
+  override get left(): OptBSTN<NODE> {
     return this._left;
   }
 
   /**
    * The function sets the left child of a node and updates the parent reference of the child.
-   * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be an
+   * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be an
    * instance of the `NODE` class or `undefined`.
    */
-  override set left(v: NODE | undefined) {
+  override set left(v: OptBSTN<NODE>) {
     if (v) {
       v.parent = this as unknown as NODE;
     }
@@ -66,16 +67,16 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
    * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
    * `undefined`.
    */
-  override get right(): NODE | undefined {
+  override get right(): OptBSTN<NODE> {
     return this._right;
   }
 
   /**
    * The function sets the right child of a node and updates the parent reference of the child.
-   * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be a
+   * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be a
    * `NODE` object or `undefined`.
    */
-  override set right(v: NODE | undefined) {
+  override set right(v: OptBSTN<NODE>) {
     if (v) {
       v.parent = this as unknown as NODE;
     }
@@ -110,7 +111,7 @@ export class BST<
    * It can include a comparator function that defines the order of the elements in the tree.
    */
   constructor(
-    keysOrNodesOrEntriesOrRawElements: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>> = [],
+    keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
     options?: BSTOptions<K, V, R>
   ) {
     super([], options);
@@ -129,7 +130,7 @@ export class BST<
    * The function returns the root node of a tree structure.
    * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
    */
-  override get root(): NODE | undefined {
+  override get root(): OptBSTN<NODE> {
     return this._root;
   }
 
@@ -162,17 +163,17 @@ export class BST<
 
   /**
    * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
-   * type R or KeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
+   * type R or BTNKeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
    * element.
    * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
    * value associated with a key in a key-value pair.
    * @returns either a NODE object or undefined.
    */
   override keyValueOrEntryOrRawElementToNode(
-    keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>,
+    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>,
     value?: V
-  ): NODE | undefined {
+  ): OptBSTN<NODE> {
     return super.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value) ?? undefined;
   }
 
@@ -182,7 +183,7 @@ export class BST<
    *
    * The function ensures the existence of a node in a data structure and returns it, or undefined if
    * it doesn't exist.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
    * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, which represents the key, node,
    * entry, or raw element that needs to be ensured in the tree.
    * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
@@ -192,21 +193,21 @@ export class BST<
    * not be ensured.
    */
   override ensureNode(
-    keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>,
+    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
-  ): NODE | undefined {
+  ): OptBSTN<NODE> {
     return super.ensureNode(keyOrNodeOrEntryOrRawElement, iterationType) ?? undefined;
   }
 
   /**
    * The function checks if the input is an instance of the BSTNode class.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
    * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
    * an instance of the `BSTNode` class.
    */
   override isNode(
-    keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>
+    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>
   ): keyOrNodeOrEntryOrRawElement is NODE {
     return keyOrNodeOrEntryOrRawElement instanceof BSTNode;
   }
@@ -216,13 +217,13 @@ export class BST<
    * Space Complexity: O(1)
    *
    * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-   * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+   * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
    * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
    * key in the binary search tree. If provided, it will be stored in the node along with the key.
    * @returns a boolean value.
    */
-  override add(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean {
+  override add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean {
     const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value);
     if (newNode === undefined) return false;
 
@@ -284,7 +285,7 @@ export class BST<
    * successfully inserted into the data structure.
    */
   override addMany(
-    keysOrNodesOrEntriesOrRawElements: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>>,
+    keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>,
     values?: Iterable<V | undefined>,
     isBalanceAdd = true,
     iterationType: IterationType = this.iterationType
@@ -308,7 +309,9 @@ export class BST<
 
     const realBTNExemplars: (R | BTNPureKeyOrNodeOrEntry<K, V, NODE>)[] = [];
 
-    const isRealBTNExemplar = (kve: R | KeyOrNodeOrEntry<K, V, NODE>): kve is BTNPureKeyOrNodeOrEntry<K, V, NODE> => {
+    const isRealBTNExemplar = (
+      kve: R | BTNKeyOrNodeOrEntry<K, V, NODE>
+    ): kve is BTNPureKeyOrNodeOrEntry<K, V, NODE> => {
       if (kve === undefined || kve === null) return false;
       return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
     };
@@ -395,7 +398,7 @@ export class BST<
    * @param [onlyOne=false] - A boolean value indicating whether to return only the first matching node
    * or all matching nodes. If set to true, only the first matching node will be returned. If set to
    * false, all matching nodes will be returned. The default value is false.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
    * point for the search in the binary tree. It can be either a node object, a key-value pair, or an
    * entry object. If it is not provided, the `root` of the binary tree is used as the starting point.
    * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -406,7 +409,7 @@ export class BST<
     identifier: ReturnType<C> | undefined,
     callback: C = this._DEFAULT_CALLBACK as C,
     onlyOne = false,
-    beginRoot: R | KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    beginRoot: R | BTNKeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE[] {
     beginRoot = this.ensureNode(beginRoot);
@@ -496,7 +499,7 @@ export class BST<
     callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: R | BSTNKeyOrNode<K, NODE> = this.root,
     iterationType: IterationType = this.iterationType
-  ): NODE | undefined {
+  ): OptBSTN<NODE> {
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
   }
 
@@ -518,7 +521,7 @@ export class BST<
    * It has a default value of `'ITERATIVE'`.
    * @returns The method is returning a NODE object or undefined.
    */
-  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
+  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): OptBSTN<NODE> {
     return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
   }
 
@@ -539,7 +542,7 @@ export class BST<
    * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
    * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
    * take one of the following values:
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
    * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
    * node entry. If not specified, the default value is the root of the tree.
    * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -550,7 +553,7 @@ export class BST<
   override dfs<C extends BTNCallback<NODE>>(
     callback: C = this._DEFAULT_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
-    beginRoot: R | KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    beginRoot: R | BTNKeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = 'ITERATIVE'
   ): ReturnType<C>[] {
     return super.dfs(callback, pattern, beginRoot, iterationType, false);
@@ -570,7 +573,7 @@ export class BST<
    * @param {C} callback - The `callback` parameter is a function that will be called for each node
    * visited during the breadth-first search. It should take a single argument, which is the current
    * node being visited, and it can return a value of any type.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
    * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
    * object. If no value is provided, the default value is the root of the tree.
    * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -580,7 +583,7 @@ export class BST<
    */
   override bfs<C extends BTNCallback<NODE>>(
     callback: C = this._DEFAULT_CALLBACK as C,
-    beginRoot: R | KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    beginRoot: R | BTNKeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     return super.bfs(callback, beginRoot, iterationType, false);
@@ -600,7 +603,7 @@ export class BST<
    * @param {C} callback - The `callback` parameter is a generic type `C` that extends
    * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
    * tree during the iteration process.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
    * point for listing the levels of the binary tree. It can be either a root node of the tree, a
    * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
    * value is provided, the root of
@@ -611,7 +614,7 @@ export class BST<
    */
   override listLevels<C extends BTNCallback<NODE>>(
     callback: C = this._DEFAULT_CALLBACK as C,
-    beginRoot: R | KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    beginRoot: R | BTNKeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[][] {
     return super.listLevels(callback, beginRoot, iterationType, false);
@@ -634,7 +637,7 @@ export class BST<
    * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
    * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
    * 0, or 1, where:
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
    * the binary tree that you want to start traversing from. It can be specified either by providing
    * the key of the node, the node itself, or an entry containing the key and value of the node. If no
    * `targetNode` is provided,
@@ -646,7 +649,7 @@ export class BST<
   lesserOrGreaterTraverse<C extends BTNCallback<NODE>>(
     callback: C = this._DEFAULT_CALLBACK as C,
     lesserOrGreater: CP = -1,
-    targetNode: R | KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    targetNode: R | BTNKeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     const targetNodeEnsured = this.ensureNode(targetNode);
@@ -760,7 +763,7 @@ export class BST<
     let balanced = true;
 
     if (iterationType === 'RECURSIVE') {
-      const _height = (cur: NODE | undefined): number => {
+      const _height = (cur: OptBSTN<NODE>): number => {
         if (!cur) return 0;
         const leftHeight = _height(cur.left),
           rightHeight = _height(cur.right);
@@ -770,8 +773,8 @@ export class BST<
       _height(this.root);
     } else {
       const stack: NODE[] = [];
-      let node: NODE | undefined = this.root,
-        last: NODE | undefined = undefined;
+      let node: OptBSTN<NODE> = this.root,
+        last: OptBSTN<NODE> = undefined;
       const depths: Map<NODE, number> = new Map();
 
       while (stack.length > 0 || node) {
@@ -827,9 +830,9 @@ export class BST<
   /**
    * The function sets the root of a tree-like structure and updates the parent property of the new
    * root.
-   * @param {NODE | undefined} v - v is a parameter of type NODE or undefined.
+   * @param {OptBSTN<NODE>} v - v is a parameter of type NODE or undefined.
    */
-  protected override _setRoot(v: NODE | undefined) {
+  protected override _setRoot(v: OptBSTN<NODE>) {
     if (v) {
       v.parent = undefined;
     }

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

@@ -1,8 +1,8 @@
 import type {
   BinaryTreeDeleteResult,
   BTNCallback,
+  BTNKeyOrNodeOrEntry,
   CRUD,
-  KeyOrNodeOrEntry,
   RBTNColor,
   RBTreeOptions,
   RedBlackTreeNested,
@@ -72,7 +72,7 @@ export class RedBlackTree<
    * depend on the implementation
    */
   constructor(
-    keysOrNodesOrEntriesOrRawElements: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>> = [],
+    keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
     options?: RBTreeOptions<K, V, R>
   ) {
     super([], options);
@@ -135,13 +135,13 @@ export class RedBlackTree<
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of the RedBlackTreeNode class.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
    * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
    * an instance of the `RedBlackTreeNode` class.
    */
   override isNode(
-    keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>
+    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>
   ): keyOrNodeOrEntryOrRawElement is NODE {
     return keyOrNodeOrEntryOrRawElement instanceof RedBlackTreeNode;
   }
@@ -157,11 +157,11 @@ export class RedBlackTree<
   //  *
   //  * The function `keyValueOrEntryOrRawElementToNode` takes a key, value, or entry and returns a node if it is
   //  * valid, otherwise it returns undefined.
-  //  * @param {KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The key, value, or entry to convert.
+  //  * @param {BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The key, value, or entry to convert.
   //  * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntryOrRawElement` is a key).
   //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
   //  */
-  // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
+  // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
   //
   //   if (keyOrNodeOrEntryOrRawElement === null || keyOrNodeOrEntryOrRawElement === undefined) return;
   //   if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
@@ -210,8 +210,8 @@ export class RedBlackTree<
    *
    * The function adds a new node to a binary search tree and returns true if the node was successfully
    * added.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-   * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+   * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<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.
@@ -219,7 +219,7 @@ export class RedBlackTree<
    * 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.
    */
-  override add(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean {
+  override add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean {
     const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value);
     if (!this.isRealNode(newNode)) return false;
 

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

@@ -9,8 +9,8 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  BTNKeyOrNodeOrEntry,
   IterationType,
-  KeyOrNodeOrEntry,
   RBTNColor,
   TreeMultiMapNested,
   TreeMultiMapNodeNested,
@@ -81,7 +81,7 @@ export class TreeMultiMap<
    * `compareValues`, which are functions used to compare keys and values respectively.
    */
   constructor(
-    keysOrNodesOrEntriesOrRawElements: Iterable<KeyOrNodeOrEntry<K, V, NODE>> = [],
+    keysOrNodesOrEntriesOrRawElements: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
     options?: TreeMultiMapOptions<K, V, R>
   ) {
     super([], options);
@@ -153,8 +153,8 @@ export class TreeMultiMap<
   /**
    * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
    * node based on the input.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<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.
@@ -163,7 +163,7 @@ export class TreeMultiMap<
    * @returns either a NODE object or undefined.
    */
   override keyValueOrEntryOrRawElementToNode(
-    keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>,
+    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>,
     value?: V,
     count = 1
   ): NODE | undefined {
@@ -190,13 +190,13 @@ export class TreeMultiMap<
 
   /**
    * The function checks if the input is an instance of the TreeMultiMapNode class.
-   * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
    * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
    * an instance of the `TreeMultiMapNode` class.
    */
   override isNode(
-    keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>
+    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>
   ): keyOrNodeOrEntryOrRawElement is NODE {
     return keyOrNodeOrEntryOrRawElement instanceof TreeMultiMapNode;
   }
@@ -212,7 +212,7 @@ export class TreeMultiMap<
    *
    * 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 {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
    * `keyOrNodeOrEntryOrRawElement` 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.
@@ -222,7 +222,7 @@ export class TreeMultiMap<
    * @returns The method is returning a boolean value. It returns true if the addition of the new node
    * was successful, and false otherwise.
    */
-  override add(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V, count = 1): boolean {
+  override add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count = 1): boolean {
     const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count);
     const orgCount = newNode?.count || 0;
     const isSuccessAdded = super.add(newNode);

package/src/data-structures/graph/directed-graph.ts

@@ -261,7 +261,8 @@ export class DirectedGraph<
     if (vertex) {
       const neighbors = this.getNeighbors(vertex);
       for (const neighbor of neighbors) {
-        this._inEdgeMap.delete(neighbor);
+        // this._inEdgeMap.delete(neighbor);
+        this.deleteEdgeSrcToDest(vertex, neighbor);
       }
       this._outEdgeMap.delete(vertex);
       this._inEdgeMap.delete(vertex);

package/src/data-structures/queue/deque.ts

@@ -32,8 +32,9 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     super(options);
 
     if (options) {
-      const { bucketSize } = options;
+      const { bucketSize, maxLen } = options;
       if (typeof bucketSize === 'number') this._bucketSize = bucketSize;
+      if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
     }
 
     let _size: number;
@@ -73,6 +74,17 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     return this._bucketSize;
   }
 
+  protected _maxLen: number = -1;
+
+  /**
+   * The maxLen function returns the max length of the deque.
+   *
+   * @return The max length of the deque
+   */
+  get maxLen() {
+    return this._maxLen;
+  }
+
   protected _bucketFirst = 0;
 
   /**
@@ -193,6 +205,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     }
     this._size += 1;
     this._buckets[this._bucketLast][this._lastInBucket] = element;
+    if (this._maxLen > 0 && this._size > this._maxLen) this.shift();
     return true;
   }
 
@@ -257,6 +270,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     }
     this._size += 1;
     this._buckets[this._bucketFirst][this._firstInBucket] = element;
+    if (this._maxLen > 0 && this._size > this._maxLen) this.pop();
     return true;
   }
 

package/src/data-structures/queue/queue.ts

@@ -100,7 +100,6 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    *
    * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
    * @public
-   * @static
    * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
    * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
    * array.

package/src/index.ts

@@ -5,7 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-// export { DirectedVertex, DirectedEdge, DirectedGraph } from 'data-structure-typed';
 export * from './data-structures/graph/directed-graph';
+export * from './data-structures/graph/abstract-graph';
 export * from './types/data-structures/graph/directed-graph';
+export * from './types/data-structures/graph/abstract-graph';
 export * from './types/common';

package/src/interfaces/binary-tree.ts

@@ -5,7 +5,7 @@ import type {
   BinaryTreeNodeNested,
   BinaryTreeOptions,
   BTNCallback,
-  KeyOrNodeOrEntry
+  BTNKeyOrNodeOrEntry
 } from '../types';
 
 export interface IBinaryTree<
@@ -19,9 +19,9 @@ export interface IBinaryTree<
 
   createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
 
-  add(keyOrNodeOrEntryOrRawElement: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
+  add(keyOrNodeOrEntryOrRawElement: BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
 
-  addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
+  addMany(nodes: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
 
   delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<NODE>[];
 }

package/src/types/common.ts

@@ -1,11 +1,5 @@
 export type CP = 1 | -1 | 0;
 
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
 export type IterationType = 'ITERATIVE' | 'RECURSIVE';
 
 export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
@@ -16,8 +10,6 @@ export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 
 export type NodeDisplayLayout = [string[], number, number, number];
 
-export type BTNCallback<N, D = any> = (node: N) => D;
-
 export interface IterableWithSize<T> extends Iterable<T> {
   size: number | ((...args: any[]) => number);
 }
@@ -26,22 +18,8 @@ export interface IterableWithLength<T> extends Iterable<T> {
   length: number | ((...args: any[]) => number);
 }
 
-export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
-
-export type BinaryTreePrintOptions = { isShowUndefined?: boolean; isShowNull?: boolean; isShowRedBlackNIL?: boolean };
-
-export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
-
-export type BTNKeyOrNode<K, N> = K | null | undefined | N;
+export type OptValue<V> = V | undefined;
 
-export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
-
-export type BTNodePureKeyOrNode<K, N> = K | N;
-
-export type BTNPureKeyOrNodeOrEntry<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
-
-export type BSTNKeyOrNode<K, N> = K | undefined | N;
-
-export type BinaryTreeDeleteResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };
+export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
 
 export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

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

@@ -1,5 +1,5 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
-import { BTNEntry, IterationType } from '../../common';
+import { IterationType, OptValue } 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, 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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
@@ -9,3 +9,23 @@ export type BinaryTreeOptions<K, V, R> = {
   iterationType?: IterationType;
   toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
 }
+
+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 BinaryTreeDeleteResult<NODE> = { deleted: OptBTNOrNull<NODE>; needBalanced: OptBTNOrNull<NODE> };
+
+export type BTNCallback<NODE, D = any> = (node: NODE) => D;

package/src/types/data-structures/binary-tree/bst.ts

@@ -9,3 +9,10 @@ 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;
+

package/src/types/data-structures/queue/deque.ts

@@ -1,3 +1,6 @@
 import { IterableElementBaseOptions } from '../base';
 
-export type DequeOptions<E, R> = { bucketSize?: number } & IterableElementBaseOptions<E, R>;
+export type DequeOptions<E, R> = {
+  bucketSize?: number,
+  maxLen?: number
+} & IterableElementBaseOptions<E, R>;