directed-graph-typed 1.52.5 → 1.52.8

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

@@ -1,14 +1,15 @@
 import type {
   BinaryTreeDeleteResult,
-  BTNCallback,
   BTNKeyOrNodeOrEntry,
+  BTNPredicate,
   CRUD,
+  OptBSTN,
   RBTNColor,
   RBTreeOptions,
   RedBlackTreeNested,
-  RedBlackTreeNodeNested
+  RedBlackTreeNodeNested,
+  BTNEntry
 } from '../../types';
-import { BTNEntry } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
@@ -64,7 +65,7 @@ export class RedBlackTree<
 {
   /**
    * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-   * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+   * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` 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
@@ -73,15 +74,15 @@ export class RedBlackTree<
    * depend on the implementation
    */
   constructor(
-    keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
+    keysOrNodesOrEntriesOrRaws: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
     options?: RBTreeOptions<K, V, R>
   ) {
     super([], options);
 
     this._root = this.NIL;
 
-    if (keysOrNodesOrEntriesOrRawElements) {
-      this.addMany(keysOrNodesOrEntriesOrRawElements);
+    if (keysOrNodesOrEntriesOrRaws) {
+      this.addMany(keysOrNodesOrEntriesOrRaws);
     }
   }
 
@@ -122,6 +123,8 @@ export class RedBlackTree<
   override createTree(options?: RBTreeOptions<K, V, R>): TREE {
     return new RedBlackTree<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
+      comparator: this._comparator,
+      toEntryFn: this._toEntryFn,
       ...options
     }) as TREE;
   }
@@ -131,15 +134,13 @@ export class RedBlackTree<
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of the RedBlackTreeNode class.
-   * @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
+   * @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
    * an instance of the `RedBlackTreeNode` class.
    */
-  override isNode(
-    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>
-  ): keyOrNodeOrEntryOrRawElement is NODE {
-    return keyOrNodeOrEntryOrRawElement instanceof RedBlackTreeNode;
+  override isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE {
+    return keyOrNodeOrEntryOrRaw instanceof RedBlackTreeNode;
   }
 
   // /**
@@ -153,27 +154,27 @@ 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 {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).
+  //  * @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).
   //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
   //  */
-  // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
+  // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): NODE | undefined {
   //
-  //   if (keyOrNodeOrEntryOrRawElement === null || keyOrNodeOrEntryOrRawElement === undefined) return;
-  //   if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
+  //   if (keyOrNodeOrEntryOrRaw === null || keyOrNodeOrEntryOrRaw === undefined) return;
+  //   if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
   //
-  //   if (this.toEntryFn) {
-  //     const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement as R);
+  //   if (this._toEntryFn) {
+  //     const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw as R);
   //     if (this.isKey(key)) return this.createNode(key, entryValue ?? value, 'RED');
   //   }
   //
-  //   if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
-  //     const [key, value] = keyOrNodeOrEntryOrRawElement;
+  //   if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
+  //     const [key, value] = keyOrNodeOrEntryOrRaw;
   //     if (key === undefined || key === null) return;
   //     else return  this.createNode(key, value, 'RED');
   //   }
   //
-  //   if (this.isKey(keyOrNodeOrEntryOrRawElement)) return this.createNode(keyOrNodeOrEntryOrRawElement, value, 'RED');
+  //   if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, 'RED');
   //
   //   return ;
   // }
@@ -196,8 +197,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 | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-   * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+   * `keyOrNodeOrEntryOrRaw` 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.
@@ -205,8 +206,8 @@ 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 | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean {
-    const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value);
+  override add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): boolean {
+    const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
     if (!this.isRealNode(newNode)) return false;
 
     const insertStatus = this._insert(newNode);
@@ -227,26 +228,23 @@ export class RedBlackTree<
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
-   * The function overrides the delete method of a binary tree data structure, allowing for the
-   * deletion of a node and maintaining the balance of the tree.
-   * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-   * that identifies the node to be deleted from the binary tree. It can be of any type that is
-   * returned by the callback function `C`. It can also be `null` or `undefined` if there is no node to
-   * delete.
-   * @param {C} callback - The `callback` parameter is a function that is used to determine the
-   * equality of nodes in the binary tree. It is optional and has a default value of
-   * `this._DEFAULT_CALLBACK`. The type of the `callback` parameter is `C`, which is a generic type
-   * that extends the `BTNCallback
-   * @returns an array of BinaryTreeDeleteResult<NODE> objects.
+   * 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`
+   * 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.
+   * @returns The `override delete` method is returning an array of `BinaryTreeDeleteResult<NODE>`
+   * objects. Each object in the array contains information about the deleted node and whether
+   * balancing is needed.
    */
-  override delete<C extends BTNCallback<NODE>>(
-    identifier: ReturnType<C> | null | undefined,
-    callback: C = this._DEFAULT_CALLBACK as C
-  ): BinaryTreeDeleteResult<NODE>[] {
-    if (identifier === null) return [];
+  override delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[] {
+    if (predicate === null) return [];
+
     const results: BinaryTreeDeleteResult<NODE>[] = [];
-    callback = this._ensureCallback(identifier, callback);
-    const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
+    let nodeToDelete: OptBSTN<NODE>;
+    if (this._isPredicated(predicate)) nodeToDelete = this.getNode(predicate);
+    else nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
 
     if (!nodeToDelete) {
       return results;

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

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 

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

@@ -1,22 +1,23 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
-  BTNCallback,
   BTNKeyOrNodeOrEntry,
+  BTNPredicate,
   IterationType,
+  OptBSTN,
   RBTNColor,
   TreeMultiMapNested,
   TreeMultiMapNodeNested,
-  TreeMultiMapOptions
+  TreeMultiMapOptions,
+  BTNEntry
 } from '../../types';
-import { BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 
@@ -74,7 +75,7 @@ export class TreeMultiMap<
 {
   /**
    * The constructor function initializes a TreeMultiMap object with optional initial data.
-   * @param keysOrNodesOrEntriesOrRawElements - The parameter `keysOrNodesOrEntriesOrRawElements` is an
+   * @param keysOrNodesOrEntriesOrRaws - The parameter `keysOrNodesOrEntriesOrRaws` 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
@@ -82,11 +83,11 @@ export class TreeMultiMap<
    * `compareValues`, which are functions used to compare keys and values respectively.
    */
   constructor(
-    keysOrNodesOrEntriesOrRawElements: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
+    keysOrNodesOrEntriesOrRaws: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
     options?: TreeMultiMapOptions<K, V, R>
   ) {
     super([], options);
-    if (keysOrNodesOrEntriesOrRawElements) this.addMany(keysOrNodesOrEntriesOrRawElements);
+    if (keysOrNodesOrEntriesOrRaws) this.addMany(keysOrNodesOrEntriesOrRaws);
   }
 
   protected _count = 0;
@@ -142,6 +143,8 @@ export class TreeMultiMap<
   override createTree(options?: TreeMultiMapOptions<K, V, R>): TREE {
     return new TreeMultiMap<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
+      comparator: this._comparator,
+      toEntryFn: this._toEntryFn,
       ...options
     }) as TREE;
   }
@@ -149,8 +152,8 @@ export class TreeMultiMap<
   /**
    * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
    * node based on the input.
-   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+   * `keyOrNodeOrEntryOrRaw` 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.
@@ -159,42 +162,39 @@ export class TreeMultiMap<
    * @returns either a NODE object or undefined.
    */
   override keyValueOrEntryOrRawElementToNode(
-    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>,
+    keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R,
     value?: V,
     count = 1
   ): NODE | undefined {
-    if (keyOrNodeOrEntryOrRawElement === undefined || keyOrNodeOrEntryOrRawElement === null) return;
+    if (keyOrNodeOrEntryOrRaw === undefined || keyOrNodeOrEntryOrRaw === null) return;
 
-    if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
+    if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
 
-    if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
-      const [key, entryValue] = keyOrNodeOrEntryOrRawElement;
+    if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
+      const [key, entryValue] = keyOrNodeOrEntryOrRaw;
       if (key === undefined || key === null) return;
       if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'BLACK', count);
     }
 
-    if (this.toEntryFn) {
-      const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement as R);
+    if (this._toEntryFn) {
+      const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw as R);
       if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'BLACK', count);
     }
 
-    if (this.isKey(keyOrNodeOrEntryOrRawElement))
-      return this.createNode(keyOrNodeOrEntryOrRawElement, value, 'BLACK', count);
+    if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, 'BLACK', count);
 
     return;
   }
 
   /**
    * The function checks if the input is an instance of the TreeMultiMapNode class.
-   * @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
+   * @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
    * an instance of the `TreeMultiMapNode` class.
    */
-  override isNode(
-    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>
-  ): keyOrNodeOrEntryOrRawElement is NODE {
-    return keyOrNodeOrEntryOrRawElement instanceof TreeMultiMapNode;
+  override isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE {
+    return keyOrNodeOrEntryOrRaw instanceof TreeMultiMapNode;
   }
 
   /**
@@ -203,8 +203,8 @@ 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 | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-   * `keyOrNodeOrEntryOrRawElement` parameter can accept one of the following types:
+   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
+   * `keyOrNodeOrEntryOrRaw` 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
@@ -213,8 +213,8 @@ 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 | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count = 1): boolean {
-    const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count);
+  override add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V, count = 1): boolean {
+    const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count);
     const orgCount = newNode?.count || 0;
     const isSuccessAdded = super.add(newNode);
 
@@ -230,30 +230,29 @@ export class TreeMultiMap<
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
-   * The function `delete` is used to remove a node from a binary tree and fix the tree if necessary.
-   * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value or
-   * key that is used to identify the node that needs to be deleted from the binary tree. It can be of
-   * any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
-   * the node to be deleted
-   * @param {C} callback - The `callback` parameter is a function that is used to determine the
-   * equality of nodes in the binary tree. It is optional and has a default value of
-   * `this._DEFAULT_CALLBACK`. The `callback` function is used to compare nodes when searching for a
-   * specific node or when performing other operations on the
-   * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
-   * being deleted. If set to true, the count of the node will not be taken into account when deleting
-   * it. If set to false, the count of the node will be decremented by 1 before deleting it.
-   * @returns an array of BinaryTreeDeleteResult<NODE> objects.
+   * 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`
+   * 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.
+   * @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.
    */
-  override delete<C extends BTNCallback<NODE>>(
-    identifier: ReturnType<C> | null | undefined,
-    callback: C = this._DEFAULT_CALLBACK as C,
+  override delete(
+    predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
-    if (identifier === null) return [];
+    if (predicate === null) return [];
+
     const results: BinaryTreeDeleteResult<NODE>[] = [];
-    callback = this._ensureCallback(identifier, callback);
 
-    const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
+    let nodeToDelete: OptBSTN<NODE>;
+    if (this._isPredicated(predicate)) nodeToDelete = this.getNode(predicate);
+    else nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
 
     if (!nodeToDelete) {
       return results;

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

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type { DijkstraResult, EntryCallback, VertexKey } from '../../types';
@@ -564,7 +564,7 @@ export abstract class AbstractGraph<
       }
     }
 
-    getMinDist &&
+    if (getMinDist)
       distMap.forEach((d, v) => {
         if (v !== srcVertex) {
           if (d < minDist) {
@@ -574,7 +574,7 @@ export abstract class AbstractGraph<
         }
       });
 
-    genPaths && getPaths(minDest);
+    if (genPaths) getPaths(minDest);
 
     return { distMap, preMap, seen, paths, minDist, minPath };
   }
@@ -761,7 +761,7 @@ export abstract class AbstractGraph<
           if (sWeight !== undefined && dWeight !== undefined) {
             if (distMap.get(s) !== Infinity && sWeight + weight < dWeight) {
               distMap.set(d, sWeight + weight);
-              genPath && preMap.set(d, s);
+              if (genPath) preMap.set(d, s);
             }
           }
         }
@@ -900,7 +900,7 @@ export abstract class AbstractGraph<
       currentPath.push(vertex.key);
 
       for (const neighbor of this.getNeighbors(vertex)) {
-        neighbor && dfs(neighbor, currentPath, visited);
+        if (neighbor) dfs(neighbor, currentPath, visited);
       }
 
       visited.delete(vertex);

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

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type { TopologicalStatus, VertexKey } from '../../types';
@@ -260,8 +260,8 @@ export class DirectedGraph<
       const v1ToV2 = this.deleteEdgeSrcToDest(v1, v2);
       const v2ToV1 = this.deleteEdgeSrcToDest(v2, v1);
 
-      v1ToV2 && removed.push(v1ToV2);
-      v2ToV1 && removed.push(v2ToV1);
+      if (v1ToV2) removed.push(v1ToV2);
+      if (v2ToV1) removed.push(v2ToV1);
     }
 
     return removed;

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

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type { VertexKey } from '../../types';

package/src/data-structures/hash/hash-map.ts

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type {
@@ -111,7 +111,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * @returns A boolean value indicating whether the size of the object is 0 or not.
    */
   isEmpty(): boolean {
-    return this.size === 0;
+    return this._size === 0;
   }
 
   /**

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

@@ -626,7 +626,7 @@ export class FibonacciHeap<E> {
    * @returns The top element or undefined if the heap is empty.
    */
   pop(): E | undefined {
-    if (this.size === 0) return undefined;
+    if (this._size === 0) return undefined;
 
     const z = this.min!;
     if (z.child) {
@@ -770,7 +770,7 @@ export class FibonacciHeap<E> {
    * @protected
    */
   protected _consolidate(): void {
-    const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
+    const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this._size);
     const elements = this.consumeLinkedList(this.root);
     let x: FibonacciHeapNode<E> | undefined,
       y: FibonacciHeapNode<E> | undefined,
@@ -798,7 +798,7 @@ export class FibonacciHeap<E> {
       A[d] = x;
     }
 
-    for (let i = 0; i < this.size; i++) {
+    for (let i = 0; i < this._size; i++) {
       if (A[i] && this.comparator(A[i]!.element, this.min!.element) <= 0) {
         this._min = A[i]!;
       }

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type { DoublyLinkedListOptions, ElementCallback } from '../../types';
@@ -267,7 +267,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * or the linked list is empty, it will return undefined.
    */
   at(index: number): E | undefined {
-    if (index < 0 || index >= this.size) return undefined;
+    if (index < 0 || index >= this._size) return undefined;
     let current = this.head;
     for (let i = 0; i < index; i++) {
       current = current!.next;
@@ -287,7 +287,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * valid range of the linked list, otherwise it returns `undefined`.
    */
   getNodeAt(index: number): DoublyLinkedListNode<E> | undefined {
-    if (index < 0 || index >= this.size) return undefined;
+    if (index < 0 || index >= this._size) return undefined;
     let current = this.head;
     for (let i = 0; i < index; i++) {
       current = current!.next;
@@ -331,12 +331,12 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * if the index is out of bounds.
    */
   addAt(index: number, value: E): boolean {
-    if (index < 0 || index > this.size) return false;
+    if (index < 0 || index > this._size) return false;
     if (index === 0) {
       this.unshift(value);
       return true;
     }
-    if (index === this.size) {
+    if (index === this._size) {
       this.push(value);
       return true;
     }
@@ -442,12 +442,12 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * bounds.
    */
   deleteAt(index: number): boolean {
-    if (index < 0 || index >= this.size) return false;
+    if (index < 0 || index >= this._size) return false;
     if (index === 0) {
       this.shift();
       return true;
     }
-    if (index === this.size - 1) {
+    if (index === this._size - 1) {
       this.pop();
       return true;
     }
@@ -505,7 +505,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @returns A boolean value is being returned.
    */
   isEmpty(): boolean {
-    return this.size === 0;
+    return this._size === 0;
   }
 
   /**

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type { ElementCallback, SinglyLinkedListOptions } from '../../types';
@@ -237,7 +237,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * `undefined` if the index is out of bounds.
    */
   at(index: number): E | undefined {
-    if (index < 0 || index >= this.size) return undefined;
+    if (index < 0 || index >= this._size) return undefined;
     let current = this.head;
     for (let i = 0; i < index; i++) {
       current = current!.next;
@@ -274,12 +274,12 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * bounds.
    */
   deleteAt(index: number): boolean {
-    if (index < 0 || index >= this.size) return false;
+    if (index < 0 || index >= this._size) return false;
     if (index === 0) {
       this.shift();
       return true;
     }
-    if (index === this.size - 1) {
+    if (index === this._size - 1) {
       this.pop();
       return true;
     }
@@ -348,12 +348,12 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * if the index is out of bounds.
    */
   addAt(index: number, value: E): boolean {
-    if (index < 0 || index > this.size) return false;
+    if (index < 0 || index > this._size) return false;
     if (index === 0) {
       this.unshift(value);
       return true;
     }
-    if (index === this.size) {
+    if (index === this._size) {
       this.push(value);
       return true;
     }
@@ -372,7 +372,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @returns A boolean value indicating whether the length of the object is equal to 0.
    */
   isEmpty(): boolean {
-    return this.size === 0;
+    return this._size === 0;
   }
 
   /**