data-structure-typed 1.40.0-rc → 1.41.0

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

@@ -8,22 +8,25 @@
 import {arrayRemove} from '../../utils';
 import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
 import type {TopologicalStatus, VertexKey} from '../../types';
-import {IDirectedGraph} from '../../interfaces';
+import {IGraph} from '../../interfaces';
 
 export class DirectedVertex<V = any> extends AbstractVertex<V> {
   /**
    * The constructor function initializes a vertex with an optional value.
    * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
    * used to uniquely identify the vertex within a graph or data structure.
-   * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
+   * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
    * vertex. If no value is provided, the vertex will be initialized with a default value.
    */
-  constructor(key: VertexKey, val?: V) {
-    super(key, val);
+  constructor(key: VertexKey, value?: V) {
+    super(key, value);
   }
 }
 
-export class DirectedEdge<V = any> extends AbstractEdge<V> {
+export class DirectedEdge<E = any> extends AbstractEdge<E> {
+  src: VertexKey;
+  dest: VertexKey;
+
   /**
    * The constructor function initializes the source and destination vertices of an edge, along with an optional weight
    * and value.
@@ -32,40 +35,24 @@ export class DirectedEdge<V = any> extends AbstractEdge<V> {
    * @param {VertexKey} dest - The `dest` parameter represents the destination vertex of an edge. It is of type
    * `VertexKey`, which is likely a unique identifier for a vertex in a graph.
    * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-   * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value associated with
+   * @param {E} [value] - The `value` parameter is an optional parameter of type `E`. It represents the value associated with
    * the edge.
    */
-  constructor(src: VertexKey, dest: VertexKey, weight?: number, val?: V) {
-    super(weight, val);
-    this._src = src;
-    this._dest = dest;
-  }
-
-  private _src: VertexKey;
-
-  get src(): VertexKey {
-    return this._src;
-  }
-
-  set src(v: VertexKey) {
-    this._src = v;
-  }
-
-  private _dest: VertexKey;
-
-  get dest(): VertexKey {
-    return this._dest;
-  }
-
-  set dest(v: VertexKey) {
-    this._dest = v;
+  constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E) {
+    super(weight, value);
+    this.src = src;
+    this.dest = dest;
   }
 }
 
-export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge>
-  extends AbstractGraph<V, E>
-  implements IDirectedGraph<V, E>
-{
+export class DirectedGraph<
+  V = any,
+  E = any,
+  VO extends DirectedVertex<V> = DirectedVertex<V>,
+  EO extends DirectedEdge<E> = DirectedEdge<E>
+>
+  extends AbstractGraph<V, E, VO, EO>
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor function initializes an instance of a class.
    */
@@ -73,15 +60,15 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
     super();
   }
 
-  private _outEdgeMap: Map<V, E[]> = new Map<V, E[]>();
+  protected _outEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
-  get outEdgeMap(): Map<V, E[]> {
+  get outEdgeMap(): Map<VO, EO[]> {
     return this._outEdgeMap;
   }
 
-  private _inEdgeMap: Map<V, E[]> = new Map<V, E[]>();
+  protected _inEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
-  get inEdgeMap(): Map<V, E[]> {
+  get inEdgeMap(): Map<VO, EO[]> {
     return this._inEdgeMap;
   }
 
@@ -94,13 +81,13 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * The function creates a new vertex with an optional value and returns it.
    * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is of type `VertexKey`, which
    * could be a number or a string depending on how you want to identify your vertices.
-   * @param [val] - The 'val' parameter is an optional value that can be assigned to the vertex. If a value is provided,
-   * it will be assigned to the 'val' property of the vertex. If no value is provided, the 'val' property will be
+   * @param [value] - The 'value' parameter is an optional value that can be assigned to the vertex. If a value is provided,
+   * it will be assigned to the 'value' property of the vertex. If no value is provided, the 'value' property will be
    * assigned the same value as the 'key' parameter
-   * @returns a new instance of a DirectedVertex object, casted as type V.
+   * @returns a new instance of a DirectedVertex object, casted as type VO.
    */
-  createVertex(key: VertexKey, val?: V['val']): V {
-    return new DirectedVertex(key, val ?? key) as V;
+  createVertex(key: VertexKey, value?: V): VO {
+    return new DirectedVertex(key, value ?? key) as VO;
   }
 
   /**
@@ -114,28 +101,28 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for the edge.
    * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge. If no
    * weight is provided, it defaults to 1.
-   * @param [val] - The 'val' parameter is an optional value that can be assigned to the edge. It can be of any type and
+   * @param [value] - The 'value' parameter is an optional value that can be assigned to the edge. It can be of any type and
    * is used to store additional information or data associated with the edge.
-   * @returns a new instance of a DirectedEdge object, casted as type E.
+   * @returns a new instance of a DirectedEdge object, casted as type EO.
    */
-  createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E['val']): E {
-    return new DirectedEdge(src, dest, weight ?? 1, val) as E;
+  createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
+    return new DirectedEdge(src, dest, weight ?? 1, value) as EO;
   }
 
   /**
    * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-   * @param {V | null | VertexKey} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-   * @param {V | null | VertexKey} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
-   * destination vertex of the edge. It can be either a vertex object (`V`), a vertex ID (`VertexKey`), or `null` if the
+   * @param {VO | VertexKey | null} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+   * @param {VO | VertexKey | null} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+   * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `null` if the
    * destination is not specified.
    * @returns the first edge found between the source and destination vertices, or null if no such edge is found.
    */
-  getEdge(srcOrKey: V | null | VertexKey, destOrKey: V | null | VertexKey): E | null {
-    let edges: E[] = [];
+  getEdge(srcOrKey: VO | VertexKey | null, destOrKey: VO | VertexKey | null): EO | null {
+    let edges: EO[] = [];
 
     if (srcOrKey !== null && destOrKey !== null) {
-      const src: V | null = this._getVertex(srcOrKey);
-      const dest: V | null = this._getVertex(destOrKey);
+      const src: VO | null = this._getVertex(srcOrKey);
+      const dest: VO | null = this._getVertex(destOrKey);
 
       if (src && dest) {
         const srcOutEdges = this._outEdgeMap.get(src);
@@ -150,49 +137,49 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
 
   /**
    * The function removes an edge between two vertices in a graph and returns the removed edge.
-   * @param {V | VertexKey} srcOrKey - The source vertex or its ID.
-   * @param {V | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
-   * @returns the removed edge (E) if it exists, or null if either the source or destination vertex does not exist.
+   * @param {VO | VertexKey} srcOrKey - The source vertex or its ID.
+   * @param {VO | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
+   * @returns the removed edge (EO) if it exists, or null if either the source or destination vertex does not exist.
    */
-  removeEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null {
-    const src: V | null = this._getVertex(srcOrKey);
-    const dest: V | null = this._getVertex(destOrKey);
-    let removed: E | null = null;
+  deleteEdgeSrcToDest(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null {
+    const src: VO | null = this._getVertex(srcOrKey);
+    const dest: VO | null = this._getVertex(destOrKey);
+    let removed: EO | null = null;
     if (!src || !dest) {
       return null;
     }
 
     const srcOutEdges = this._outEdgeMap.get(src);
     if (srcOutEdges) {
-      arrayRemove<E>(srcOutEdges, (edge: E) => edge.dest === dest.key);
+      arrayRemove<EO>(srcOutEdges, (edge: EO) => edge.dest === dest.key);
     }
 
     const destInEdges = this._inEdgeMap.get(dest);
     if (destInEdges) {
-      removed = arrayRemove<E>(destInEdges, (edge: E) => edge.src === src.key)[0] || null;
+      removed = arrayRemove<EO>(destInEdges, (edge: EO) => edge.src === src.key)[0] || null;
     }
     return removed;
   }
 
   /**
    * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
-   * @param {E} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
+   * @param {EO} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
    * and `dest`, which represent the source and destination vertices of the edge, respectively.
-   * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+   * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `null` if the edge does not exist.
    */
-  removeEdge(edge: E): E | null {
-    let removed: E | null = null;
+  deleteEdge(edge: EO): EO | null {
+    let removed: EO | null = null;
     const src = this._getVertex(edge.src);
     const dest = this._getVertex(edge.dest);
     if (src && dest) {
       const srcOutEdges = this._outEdgeMap.get(src);
       if (srcOutEdges && srcOutEdges.length > 0) {
-        arrayRemove(srcOutEdges, (edge: E) => edge.src === src.key);
+        arrayRemove(srcOutEdges, (edge: EO) => edge.src === src.key);
       }
 
       const destInEdges = this._inEdgeMap.get(dest);
       if (destInEdges && destInEdges.length > 0) {
-        removed = arrayRemove(destInEdges, (edge: E) => edge.dest === dest.key)[0];
+        removed = arrayRemove(destInEdges, (edge: EO) => edge.dest === dest.key)[0];
       }
     }
 
@@ -201,18 +188,18 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
 
   /**
    * The function removes edges between two vertices and returns the removed edges.
-   * @param {VertexKey | V} v1 - The parameter `v1` can be either a `VertexKey` or a `V`. A `VertexKey` represents the
-   * unique identifier of a vertex in a graph, while `V` represents the actual vertex object.
-   * @param {VertexKey | V} v2 - The parameter `v2` represents either a `VertexKey` or a `V` object. It is used to specify
+   * @param {VertexKey | VO} v1 - The parameter `v1` can be either a `VertexKey` or a `VO`. A `VertexKey` represents the
+   * unique identifier of a vertex in a graph, while `VO` represents the actual vertex object.
+   * @param {VertexKey | VO} v2 - The parameter `v2` represents either a `VertexKey` or a `VO` object. It is used to specify
    * the second vertex in the edge that needs to be removed.
-   * @returns an array of removed edges (E[]).
+   * @returns an array of removed edges (EO[]).
    */
-  removeEdgesBetween(v1: VertexKey | V, v2: VertexKey | V): E[] {
-    const removed: E[] = [];
+  deleteEdgesBetween(v1: VertexKey | VO, v2: VertexKey | VO): EO[] {
+    const removed: EO[] = [];
 
     if (v1 && v2) {
-      const v1ToV2 = this.removeEdgeSrcToDest(v1, v2);
-      const v2ToV1 = this.removeEdgeSrcToDest(v2, v1);
+      const v1ToV2 = this.deleteEdgeSrcToDest(v1, v2);
+      const v2ToV1 = this.deleteEdgeSrcToDest(v2, v1);
 
       v1ToV2 && removed.push(v1ToV2);
       v2ToV1 && removed.push(v2ToV1);
@@ -223,11 +210,11 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
 
   /**
    * The function `incomingEdgesOf` returns an array of incoming edges for a given vertex or vertex ID.
-   * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
    * (`VertexKey`).
-   * @returns The method `incomingEdgesOf` returns an array of edges (`E[]`).
+   * @returns The method `incomingEdgesOf` returns an array of edges (`EO[]`).
    */
-  incomingEdgesOf(vertexOrKey: V | VertexKey): E[] {
+  incomingEdgesOf(vertexOrKey: VO | VertexKey): EO[] {
     const target = this._getVertex(vertexOrKey);
     if (target) {
       return this.inEdgeMap.get(target) || [];
@@ -237,11 +224,11 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
 
   /**
    * The function `outgoingEdgesOf` returns an array of outgoing edges from a given vertex or vertex ID.
-   * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can accept either a vertex object (`V`) or a vertex ID
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can accept either a vertex object (`VO`) or a vertex ID
    * (`VertexKey`).
-   * @returns The method `outgoingEdgesOf` returns an array of edges (`E[]`).
+   * @returns The method `outgoingEdgesOf` returns an array of edges (`EO[]`).
    */
-  outgoingEdgesOf(vertexOrKey: V | VertexKey): E[] {
+  outgoingEdgesOf(vertexOrKey: VO | VertexKey): EO[] {
     const target = this._getVertex(vertexOrKey);
     if (target) {
       return this._outEdgeMap.get(target) || [];
@@ -251,69 +238,69 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
 
   /**
    * The function "degreeOf" returns the total degree of a vertex, which is the sum of its out-degree and in-degree.
-   * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+   * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
    * @returns The sum of the out-degree and in-degree of the specified vertex or vertex ID.
    */
-  degreeOf(vertexOrKey: VertexKey | V): number {
+  degreeOf(vertexOrKey: VertexKey | VO): number {
     return this.outDegreeOf(vertexOrKey) + this.inDegreeOf(vertexOrKey);
   }
 
   /**
    * The function "inDegreeOf" returns the number of incoming edges for a given vertex.
-   * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+   * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
    * @returns The number of incoming edges of the specified vertex or vertex ID.
    */
-  inDegreeOf(vertexOrKey: VertexKey | V): number {
+  inDegreeOf(vertexOrKey: VertexKey | VO): number {
     return this.incomingEdgesOf(vertexOrKey).length;
   }
 
   /**
    * The function `outDegreeOf` returns the number of outgoing edges from a given vertex.
-   * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+   * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
    * @returns The number of outgoing edges from the specified vertex or vertex ID.
    */
-  outDegreeOf(vertexOrKey: VertexKey | V): number {
+  outDegreeOf(vertexOrKey: VertexKey | VO): number {
     return this.outgoingEdgesOf(vertexOrKey).length;
   }
 
   /**
    * The function "edgesOf" returns an array of both outgoing and incoming edges of a given vertex or vertex ID.
-   * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+   * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
    * @returns The function `edgesOf` returns an array of edges.
    */
-  edgesOf(vertexOrKey: VertexKey | V): E[] {
+  edgesOf(vertexOrKey: VertexKey | VO): EO[] {
     return [...this.outgoingEdgesOf(vertexOrKey), ...this.incomingEdgesOf(vertexOrKey)];
   }
 
   /**
    * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
-   * @param {E} e - The parameter "e" is of type E, which represents an edge in a graph.
-   * @returns either a vertex object (V) or null.
+   * @param {EO} e - The parameter "e" is of type EO, which represents an edge in a graph.
+   * @returns either a vertex object (VO) or null.
    */
-  getEdgeSrc(e: E): V | null {
+  getEdgeSrc(e: EO): VO | null {
     return this._getVertex(e.src);
   }
 
   /**
    * The function "getEdgeDest" returns the destination vertex of an edge.
-   * @param {E} e - The parameter "e" is of type "E", which represents an edge in a graph.
-   * @returns either a vertex object of type V or null.
+   * @param {EO} e - The parameter "e" is of type "EO", which represents an edge in a graph.
+   * @returns either a vertex object of type VO or null.
    */
-  getEdgeDest(e: E): V | null {
+  getEdgeDest(e: EO): VO | null {
     return this._getVertex(e.dest);
   }
 
   /**
    * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
-   * @param {V | VertexKey | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
-   * find the destinations. It can be either a `V` object, a `VertexKey` value, or `null`.
-   * @returns an array of vertices (V[]).
+   * @param {VO | VertexKey | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
+   * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `null`.
+   * @returns an array of vertices (VO[]).
    */
-  getDestinations(vertex: V | VertexKey | null): V[] {
+  getDestinations(vertex: VO | VertexKey | null): VO[] {
     if (vertex === null) {
       return [];
     }
-    const destinations: V[] = [];
+    const destinations: VO[] = [];
     const outgoingEdges = this.outgoingEdgesOf(vertex);
     for (const outEdge of outgoingEdges) {
       const child = this.getEdgeDest(outEdge);
@@ -332,18 +319,18 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * specified, the vertices themselves will be used for sorting. If 'key' is specified, the ids of
    * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns null.
    */
-  topologicalSort(propertyName?: 'vertex' | 'key'): Array<V | VertexKey> | null {
+  topologicalSort(propertyName?: 'vertex' | 'key'): Array<VO | VertexKey> | null {
     propertyName = propertyName ?? 'key';
     // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
     // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
-    const statusMap: Map<V | VertexKey, TopologicalStatus> = new Map<V | VertexKey, TopologicalStatus>();
+    const statusMap: Map<VO | VertexKey, TopologicalStatus> = new Map<VO | VertexKey, TopologicalStatus>();
     for (const entry of this.vertices) {
       statusMap.set(entry[1], 0);
     }
 
-    let sorted: (V | VertexKey)[] = [];
+    let sorted: (VO | VertexKey)[] = [];
     let hasCycle = false;
-    const dfs = (cur: V | VertexKey) => {
+    const dfs = (cur: VO | VertexKey) => {
       statusMap.set(cur, 1);
       const children = this.getDestinations(cur);
       for (const child of children) {
@@ -372,10 +359,10 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
 
   /**
    * The `edgeSet` function returns an array of all the edges in the graph.
-   * @returns The `edgeSet()` method returns an array of edges (`E[]`).
+   * @returns The `edgeSet()` method returns an array of edges (`EO[]`).
    */
-  edgeSet(): E[] {
-    let edges: E[] = [];
+  edgeSet(): EO[] {
+    let edges: EO[] = [];
     this._outEdgeMap.forEach(outEdges => {
       edges = [...edges, ...outEdges];
     });
@@ -384,12 +371,12 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
 
   /**
    * The function `getNeighbors` returns an array of neighboring vertices of a given vertex or vertex ID in a graph.
-   * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
    * (`VertexKey`).
-   * @returns an array of vertices (V[]).
+   * @returns an array of vertices (VO[]).
    */
-  getNeighbors(vertexOrKey: V | VertexKey): V[] {
-    const neighbors: V[] = [];
+  getNeighbors(vertexOrKey: VO | VertexKey): VO[] {
+    const neighbors: VO[] = [];
     const vertex = this._getVertex(vertexOrKey);
     if (vertex) {
       const outEdges = this.outgoingEdgesOf(vertex);
@@ -407,11 +394,11 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
   /**
    * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it exists in the graph,
    * otherwise it returns null.
-   * @param {E} edge - The parameter `edge` is of type `E`, which represents an edge in a graph.
-   * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
+   * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph.
+   * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
    * graph. If the edge does not exist, it returns `null`.
    */
-  getEndsOfEdge(edge: E): [V, V] | null {
+  getEndsOfEdge(edge: EO): [VO, VO] | null {
     if (!this.hasEdge(edge.src, edge.dest)) {
       return null;
     }
@@ -426,12 +413,12 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
 
   /**
    * The function `_addEdgeOnly` adds an edge to a graph if the source and destination vertices exist.
-   * @param {E} edge - The parameter `edge` is of type `E`, which represents an edge in a graph. It is the edge that
+   * @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: E): boolean {
+  protected _addEdgeOnly(edge: EO): boolean {
     if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
       return false;
     }
@@ -459,12 +446,4 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
       return false;
     }
   }
-
-  protected _setOutEdgeMap(value: Map<V, E[]>) {
-    this._outEdgeMap = value;
-  }
-
-  protected _setInEdgeMap(value: Map<V, E[]>) {
-    this._inEdgeMap = value;
-  }
 }

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

@@ -2,6 +2,9 @@ import {MapGraphCoordinate, VertexKey} from '../../types';
 import {DirectedEdge, DirectedGraph, DirectedVertex} from './directed-graph';
 
 export class MapVertex<V = any> extends DirectedVertex<V> {
+  lat: number;
+  long: number;
+
   /**
    * The constructor function initializes an object with an key, latitude, longitude, and an optional value.
    * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex.
@@ -11,37 +14,17 @@ export class MapVertex<V = any> extends DirectedVertex<V> {
    * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
    * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
    * values ranging from -180 to 180.
-   * @param {V} [val] - The "val" parameter is an optional value of type V. It is not required to be provided when
+   * @param {V} [value] - The "value" parameter is an optional value of type V. It is not required to be provided when
    * creating an instance of the class.
    */
-  constructor(key: VertexKey, lat: number, long: number, val?: V) {
-    super(key, val);
-    this._lat = lat;
-    this._long = long;
-  }
-
-  private _lat: number;
-
-  get lat(): number {
-    return this._lat;
-  }
-
-  set lat(value: number) {
-    this._lat = value;
-  }
-
-  private _long: number;
-
-  get long(): number {
-    return this._long;
-  }
-
-  set long(value: number) {
-    this._long = value;
+  constructor(key: VertexKey, value: V, lat: number, long: number) {
+    super(key, value);
+    this.lat = lat;
+    this.long = long;
   }
 }
 
-export class MapEdge<V = any> extends DirectedEdge<V> {
+export class MapEdge<E = any> extends DirectedEdge<E> {
   /**
    * The constructor function initializes a new instance of a class with the given source, destination, weight, and
    * value.
@@ -49,18 +32,20 @@ export class MapEdge<V = any> extends DirectedEdge<V> {
    * a graph.
    * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
    * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-   * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store additional
+   * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store additional
    * information or data associated with the edge.
    */
-  constructor(src: VertexKey, dest: VertexKey, weight?: number, val?: V) {
-    super(src, dest, weight, val);
+  constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E) {
+    super(src, dest, weight, value);
   }
 }
 
-export class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEdge = MapEdge> extends DirectedGraph<
-  V,
-  E
-> {
+export class MapGraph<
+  V = any,
+  E = any,
+  VO extends MapVertex<V> = MapVertex<V>,
+  EO extends MapEdge<E> = MapEdge<E>
+> extends DirectedGraph<V, E, VO, EO> {
   /**
    * The constructor function initializes the origin and bottomRight properties of a MapGraphCoordinate object.
    * @param {MapGraphCoordinate} origin - The `origin` parameter is a `MapGraphCoordinate` object that represents the
@@ -76,44 +61,31 @@ export class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEd
     this._bottomRight = bottomRight;
   }
 
-  private _origin: MapGraphCoordinate = [0, 0];
+  protected _origin: MapGraphCoordinate = [0, 0];
 
   get origin(): MapGraphCoordinate {
     return this._origin;
   }
 
-  set origin(value: MapGraphCoordinate) {
-    this._origin = value;
-  }
-
-  private _bottomRight: MapGraphCoordinate | undefined;
+  protected _bottomRight: MapGraphCoordinate | undefined;
 
   get bottomRight(): MapGraphCoordinate | undefined {
     return this._bottomRight;
   }
 
-  set bottomRight(value: MapGraphCoordinate | undefined) {
-    this._bottomRight = value;
-  }
-
   /**
    * The function creates a new vertex with the given key, value, latitude, and longitude.
    * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could
    * be a string or a number depending on how you define it in your code.
-   * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the vertex. It
-   * is of type `V['val']`, which means it should be of the same type as the `val` property of the vertex class `V`.
+   * @param [value] - The `value` parameter is an optional value that can be assigned to the `value` property of the vertex. It
+   * is of type `V`, which means it should be of the same type as the `value` property of the vertex class `VO`.
    * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
    * position of the vertex on the Earth's surface in the north-south direction.
    * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
-   * @returns The method is returning a new instance of the `MapVertex` class, casted as type `V`.
+   * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
    */
-  override createVertex(
-    key: VertexKey,
-    val?: V['val'],
-    lat: number = this.origin[0],
-    long: number = this.origin[1]
-  ): V {
-    return new MapVertex(key, lat, long, val) as V;
+  override createVertex(key: VertexKey, value?: V, lat: number = this.origin[0], long: number = this.origin[1]): VO {
+    return new MapVertex(key, value, lat, long) as VO;
   }
 
   /**
@@ -124,11 +96,11 @@ export class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEd
    * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. It
    * is used to assign a numerical value to the edge, which can be used in algorithms such as shortest path algorithms.
    * If the weight is not provided, it can be set to a default value or left undefined.
-   * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
+   * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type,
    * depending on the specific implementation of the `MapEdge` class.
-   * @returns a new instance of the `MapEdge` class, casted as type `E`.
+   * @returns a new instance of the `MapEdge` class, cast as type `EO`.
    */
-  override createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E['val']): E {
-    return new MapEdge(src, dest, weight, val) as E;
+  override createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
+    return new MapEdge(src, dest, weight, value) as EO;
   }
 }