directed-graph-typed 1.49.1 → 1.49.3

package/dist/data-structures/queue/queue.d.ts

@@ -32,6 +32,32 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
      */
     get size(): number;
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
+     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
+     */
+    get first(): E | undefined;
+    /**
+     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
+     * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
+     * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * array is empty, it returns `undefined`.
+     */
+    get last(): E | undefined;
+    /**
+     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
+     * Space Complexity: O(1) - no additional space is used.
+     */
     /**
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
@@ -42,7 +68,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      */
     static fromArray<E>(elements: E[]): Queue<E>;
     /**
-     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -53,9 +79,9 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
      * @returns The `add` method is returning a `Queue<E>` object.
      */
-    push(element: E): Queue<E>;
+    push(element: E): boolean;
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -67,19 +93,6 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
      */
     shift(): E | undefined;
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     */
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     *
-     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
-     */
-    getFirst(): E | undefined;
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -93,19 +106,6 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek(): E | undefined;
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     */
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     *
-     * The `getLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
-     * array is empty, it returns `undefined`.
-     */
-    getLast(): E | undefined;
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -130,7 +130,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * The enqueue function adds a value to the end of a queue.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
-    enqueue(value: E): Queue<E>;
+    enqueue(value: E): boolean;
     /**
      * Time Complexity: O(n) - same as shift().
      * Space Complexity: O(1) - same as shift().
@@ -194,7 +194,6 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone(): Queue<E>;
-    print(): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -239,7 +238,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
 }
 /**
  * 1. First In, First Out (FIFO) Strategy: Like other queue implementations, LinkedListQueue follows the first in, first out principle, meaning the element that is added to the queue first will be the first to be removed.
@@ -248,21 +247,21 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
  * 4. Frequent Enqueuing and Dequeuing Operations: If your application involves frequent enqueuing and dequeuing operations and is less concerned with random access, then LinkedListQueue is a good choice.
  */
 export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
+    /**
+     * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    get first(): E | undefined;
     /**
      * The enqueue function adds a value to the end of an array.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
-    enqueue(value: E): void;
+    enqueue(value: E): boolean;
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
      * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
      */
     dequeue(): E | undefined;
-    /**
-     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    getFirst(): E | undefined;
     /**
      * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
      * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.

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

@@ -37,6 +37,36 @@ class Queue extends base_1.IterableElementBase {
     get size() {
         return this.nodes.length - this.offset;
     }
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
+     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
+     */
+    get first() {
+        return this.size > 0 ? this.nodes[this.offset] : undefined;
+    }
+    /**
+     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
+     * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
+     * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * array is empty, it returns `undefined`.
+     */
+    get last() {
+        return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
+    }
+    /**
+     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
+     * Space Complexity: O(1) - no additional space is used.
+     */
     /**
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
@@ -49,7 +79,7 @@ class Queue extends base_1.IterableElementBase {
         return new Queue(elements);
     }
     /**
-     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -62,10 +92,10 @@ class Queue extends base_1.IterableElementBase {
      */
     push(element) {
         this.nodes.push(element);
-        return this;
+        return true;
     }
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -79,7 +109,7 @@ class Queue extends base_1.IterableElementBase {
     shift() {
         if (this.size === 0)
             return undefined;
-        const first = this.getFirst();
+        const first = this.first;
         this._offset += 1;
         if (this.offset * 2 < this.nodes.length)
             return first;
@@ -89,21 +119,6 @@ class Queue extends base_1.IterableElementBase {
         this._offset = 0;
         return first;
     }
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     */
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     *
-     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
-     */
-    getFirst() {
-        return this.size > 0 ? this.nodes[this.offset] : undefined;
-    }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -117,22 +132,7 @@ class Queue extends base_1.IterableElementBase {
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek() {
-        return this.getFirst();
-    }
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     */
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     *
-     * The `getLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
-     * array is empty, it returns `undefined`.
-     */
-    getLast() {
-        return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
+        return this.first;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
@@ -147,7 +147,7 @@ class Queue extends base_1.IterableElementBase {
      * array is empty, it returns `undefined`.
      */
     peekLast() {
-        return this.getLast();
+        return this.last;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
@@ -239,9 +239,6 @@ class Queue extends base_1.IterableElementBase {
     clone() {
         return new Queue(this.nodes.slice(this.offset));
     }
-    print() {
-        console.log([...this]);
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -318,12 +315,20 @@ exports.Queue = Queue;
  * 4. Frequent Enqueuing and Dequeuing Operations: If your application involves frequent enqueuing and dequeuing operations and is less concerned with random access, then LinkedListQueue is a good choice.
  */
 class LinkedListQueue extends linked_list_1.SinglyLinkedList {
+    /**
+     * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    get first() {
+        var _a;
+        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.value;
+    }
     /**
      * The enqueue function adds a value to the end of an array.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
     enqueue(value) {
-        this.push(value);
+        return this.push(value);
     }
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
@@ -332,20 +337,12 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
     dequeue() {
         return this.shift();
     }
-    /**
-     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    getFirst() {
-        var _a;
-        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.value;
-    }
     /**
      * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
      * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
     peek() {
-        return this.getFirst();
+        return this.first;
     }
 }
 exports.LinkedListQueue = LinkedListQueue;

package/dist/data-structures/stack/stack.d.ts

@@ -73,7 +73,7 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
      * @returns The `push` method is returning the updated `Stack<E>` object.
      */
-    push(element: E): Stack<E>;
+    push(element: E): boolean;
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
@@ -154,10 +154,9 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * @returns The `map` method is returning a new `Stack` object.
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): Stack<T>;
-    print(): void;
     /**
      * Custom iterator for the Stack class.
      * @returns An iterator object.
      */
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
 }

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

@@ -89,7 +89,7 @@ class Stack extends base_1.IterableElementBase {
      */
     push(element) {
         this.elements.push(element);
-        return this;
+        return true;
     }
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
@@ -105,7 +105,7 @@ class Stack extends base_1.IterableElementBase {
      */
     pop() {
         if (this.isEmpty())
-            return undefined;
+            return;
         return this.elements.pop();
     }
     /**
@@ -199,9 +199,6 @@ class Stack extends base_1.IterableElementBase {
         }
         return newStack;
     }
-    print() {
-        console.log([...this]);
-    }
     /**
      * Custom iterator for the Stack class.
      * @returns An iterator object.

package/dist/data-structures/trie/trie.d.ts

@@ -172,7 +172,7 @@ export declare class Trie extends IterableElementBase<string> {
      * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
-    filter(predicate: ElementCallback<string, boolean>, thisArg?: any): string[];
+    filter(predicate: ElementCallback<string, boolean>, thisArg?: any): Trie;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -191,7 +191,6 @@ export declare class Trie extends IterableElementBase<string> {
      * @returns The `map` function is returning a new Trie object.
      */
     map(callback: ElementCallback<string, string>, thisArg?: any): Trie;
-    print(): void;
     protected _getIterator(): IterableIterator<string>;
     /**
      * Time Complexity: O(M), where M is the length of the input string.

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

@@ -341,11 +341,11 @@ class Trie extends base_1.IterableElementBase {
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
     filter(predicate, thisArg) {
-        const results = [];
+        const results = new Trie();
         let index = 0;
         for (const word of this) {
             if (predicate.call(thisArg, word, index, this)) {
-                results.push(word);
+                results.add(word);
             }
             index++;
         }
@@ -377,9 +377,6 @@ class Trie extends base_1.IterableElementBase {
         }
         return newTrie;
     }
-    print() {
-        console.log([...this]);
-    }
     *_getIterator() {
         function* _dfs(node, path) {
             if (node.isEnd) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directed-graph-typed",
-  "version": "1.49.1",
+  "version": "1.49.3",
   "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.49.1"
+    "data-structure-typed": "^1.49.3"
   }
 }

package/src/data-structures/base/iterable-base.ts

@@ -181,6 +181,21 @@ export abstract class IterableEntryBase<K = any, V = any> {
     return accumulator;
   }
 
+  hasValue(value: V): boolean {
+    for (const [, elementValue] of this) {
+      if (elementValue === value) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+  print(): void {
+    console.log([...this])
+  }
+
   protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
 }
 
@@ -325,5 +340,14 @@ export abstract class IterableElementBase<V> {
     return accumulator;
   }
 
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+  print(): void {
+    console.log([...this])
+  }
+
   protected abstract _getIterator(...args: any[]): IterableIterator<V>;
 }

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

@@ -156,10 +156,10 @@ export abstract class AbstractGraph<
 
   addVertex(keyOrVertex: VertexKey | VO, value?: V): boolean {
     if (keyOrVertex instanceof AbstractVertex) {
-      return this._addVertexOnly(keyOrVertex);
+      return this._addVertex(keyOrVertex);
     } else {
       const newVertex = this.createVertex(keyOrVertex, value);
-      return this._addVertexOnly(newVertex);
+      return this._addVertex(newVertex);
     }
   }
 
@@ -242,14 +242,14 @@ export abstract class AbstractGraph<
 
   addEdge(srcOrEdge: VO | VertexKey | EO, dest?: VO | VertexKey, weight?: number, value?: E): boolean {
     if (srcOrEdge instanceof AbstractEdge) {
-      return this._addEdgeOnly(srcOrEdge);
+      return this._addEdge(srcOrEdge);
     } else {
       if (dest instanceof AbstractVertex || typeof dest === 'string' || typeof dest === 'number') {
         if (!(this.hasVertex(srcOrEdge) && this.hasVertex(dest))) return false;
         if (srcOrEdge instanceof AbstractVertex) srcOrEdge = srcOrEdge.key;
         if (dest instanceof AbstractVertex) dest = dest.key;
         const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
-        return this._addEdgeOnly(newEdge);
+        return this._addEdge(newEdge);
       } else {
         throw new Error('dest must be a Vertex or vertex key while srcOrEdge is an Edge');
       }
@@ -1147,14 +1147,6 @@ export abstract class AbstractGraph<
     return this.tarjan(false, false, false, false).lowMap;
   }
 
-  /**
-   * The function `getCycles` returns a map of cycles found using the Tarjan algorithm.
-   * @returns The function `getCycles()` is returning a `Map<number, VO[]>`.
-   */
-  getCycles(): Map<number, VO[]> {
-    return this.tarjan(false, false, false, true).cycles;
-  }
-
   /**
    * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
    * @returns an array of VO objects, specifically the cut vertexes.
@@ -1180,6 +1172,55 @@ export abstract class AbstractGraph<
     return this.tarjan(false, true, false, false).bridges;
   }
 
+  /**
+   * O(V+E+C)
+   * O(V+C)
+   */
+  getCycles(isInclude2Cycle: boolean = false): VertexKey[][] {
+    const cycles: VertexKey[][] = [];
+    const visited: Set<VO> = new Set();
+
+    const dfs = (vertex: VO, currentPath: VertexKey[], visited: Set<VO>) => {
+      if (visited.has(vertex)) {
+        if ((!isInclude2Cycle && currentPath.length > 2 || isInclude2Cycle && currentPath.length >= 2) && currentPath[0] === vertex.key) {
+          cycles.push([...currentPath]);
+        }
+        return;
+      }
+
+      visited.add(vertex);
+      currentPath.push(vertex.key);
+
+      for (const neighbor of this.getNeighbors(vertex)) {
+        neighbor && dfs(neighbor, currentPath, visited);
+      }
+
+      visited.delete(vertex);
+      currentPath.pop();
+    };
+
+    for (const vertex of this.vertexMap.values()) {
+      dfs(vertex, [], visited);
+    }
+
+    // Use a set to eliminate duplicate cycles
+    const uniqueCycles = new Map<string, VertexKey[]>();
+
+    for (const cycle of cycles) {
+      const sorted = [...cycle].sort().toString()
+
+      if (uniqueCycles.has(sorted)) continue
+      else {
+        uniqueCycles.set(sorted, cycle)
+      }
+    }
+
+    // Convert the unique cycles back to an array
+    return [...uniqueCycles].map(cycleString =>
+      cycleString[1]
+    );
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -1247,9 +1288,9 @@ export abstract class AbstractGraph<
     }
   }
 
-  protected abstract _addEdgeOnly(edge: EO): boolean;
+  protected abstract _addEdge(edge: EO): boolean;
 
-  protected _addVertexOnly(newVertex: VO): boolean {
+  protected _addVertex(newVertex: VO): boolean {
     if (this.hasVertex(newVertex)) {
       return false;
       // throw (new Error('Duplicated vertex key is not allowed'));

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

@@ -596,6 +596,7 @@ export class DirectedGraph<
     }
   }
 
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -605,13 +606,13 @@ export class DirectedGraph<
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function `_addEdgeOnly` adds an edge to a graph if the source and destination vertexMap exist.
+   * The function `_addEdge` adds an edge to a graph if the source and destination vertexMap exist.
    * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph. It is the edge that
    * needs to be added to the graph.
    * @returns a boolean value. It returns true if the edge was successfully added to the graph, and false if either the
    * source or destination vertex does not exist in the graph.
    */
-  protected _addEdgeOnly(edge: EO): boolean {
+  protected _addEdge(edge: EO): boolean {
     if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
       return false;
     }

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

@@ -381,7 +381,7 @@ export class UndirectedGraph<
    * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
    * @returns a boolean value.
    */
-  protected _addEdgeOnly(edge: EO): boolean {
+  protected _addEdge(edge: EO): boolean {
     for (const end of edge.vertexMap) {
       const endVertex = this._getVertex(end);
       if (endVertex === undefined) return false;