directed-graph-typed 1.39.5 → 1.40.0

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

@@ -12,75 +12,42 @@ import {IGraph} from '../../interfaces';
 import {Queue} from '../queue';
 
 export abstract class AbstractVertex<V = any> {
+  key: VertexKey;
+  value: V | undefined;
+
   /**
    * The function is a protected constructor that takes an key and an optional value as parameters.
    * @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 object.
-   * @param {V} [val] - The parameter "val" is an optional parameter of type V. It is used to assign a value to the
+   * @param {V} [value] - The parameter "value" is an optional parameter of type V. It is used to assign a value to the
    * vertex. If no value is provided, it will be set to undefined.
    */
-  protected constructor(key: VertexKey, val?: V) {
-    this._key = key;
-    this._val = val;
-  }
-
-  private _key: VertexKey;
-
-  get key(): VertexKey {
-    return this._key;
-  }
-
-  set key(v: VertexKey) {
-    this._key = v;
-  }
-
-  private _val: V | undefined;
-
-  get val(): V | undefined {
-    return this._val;
+  protected constructor(key: VertexKey, value?: V) {
+    this.key = key;
+    this.value = value;
   }
 
-  set val(value: V | undefined) {
-    this._val = value;
-  }
 }
 
-export abstract class AbstractEdge<VO = any> {
+export abstract class AbstractEdge<E = any> {
+  value: E | undefined;
+  weight: number;
+
   /**
    * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
    * object.
    * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the object. If
    * a value is provided, it will be assigned to the `_weight` property. If no value is provided, the default value of 1
    * will be assigned.
-   * @param {VO} [val] - The `val` parameter is of type `VO`, which means it can be any type. It is an optional parameter,
+   * @param {VO} [value] - The `value` parameter is of type `VO`, which means it can be any type. It is an optional parameter,
    * meaning it can be omitted when creating an instance of the class.
    */
-  protected constructor(weight?: number, val?: VO) {
-    this._weight = weight !== undefined ? weight : 1;
-    this._val = val;
+  protected constructor(weight?: number, value?: E) {
+    this.weight = weight !== undefined ? weight : 1;
+    this.value = value;
     this._hashCode = uuidV4();
   }
 
-  private _val: VO | undefined;
-
-  get val(): VO | undefined {
-    return this._val;
-  }
-
-  set val(value: VO | undefined) {
-    this._val = value;
-  }
-
-  private _weight: number;
-
-  get weight(): number {
-    return this._weight;
-  }
-
-  set weight(v: number) {
-    this._weight = v;
-  }
-
   protected _hashCode: string;
 
   get hashCode(): string {
@@ -91,15 +58,6 @@ export abstract class AbstractEdge<VO = any> {
    * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
    * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
    */
-
-  /**
-   * The function sets the value of the _hashCode property to the provided string.
-   * @param {string} v - The parameter "v" is of type string and represents the value that will be assigned to the
-   * "_hashCode" property.
-   */
-  protected _setHashCode(v: string) {
-    this._hashCode = v;
-  }
 }
 
 export abstract class AbstractGraph<
@@ -107,9 +65,8 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> implements IGraph<V, E, VO, EO>
-{
-  private _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
+> implements IGraph<V, E, VO, EO> {
+  protected _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
 
   get vertices(): Map<VertexKey, VO> {
     return this._vertices;
@@ -119,9 +76,9 @@ export abstract class AbstractGraph<
    * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
    * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
    * @param key
-   * @param val
+   * @param value
    */
-  abstract createVertex(key: VertexKey, val?: V): VO;
+  abstract createVertex(key: VertexKey, value?: V): VO;
 
   /**
    * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
@@ -129,9 +86,9 @@ export abstract class AbstractGraph<
    * @param srcOrV1
    * @param destOrV2
    * @param weight
-   * @param val
+   * @param value
    */
-  abstract createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): EO;
+  abstract createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
 
   abstract deleteEdge(edge: EO): EO | null;
 
@@ -170,13 +127,13 @@ export abstract class AbstractGraph<
 
   addVertex(vertex: VO): boolean;
 
-  addVertex(key: VertexKey, val?: V): boolean;
+  addVertex(key: VertexKey, value?: V): boolean;
 
-  addVertex(keyOrVertex: VertexKey | VO, val?: V): boolean {
+  addVertex(keyOrVertex: VertexKey | VO, value?: V): boolean {
     if (keyOrVertex instanceof AbstractVertex) {
       return this._addVertexOnly(keyOrVertex);
     } else {
-      const newVertex = this.createVertex(keyOrVertex, val);
+      const newVertex = this.createVertex(keyOrVertex, value);
       return this._addVertexOnly(newVertex);
     }
   }
@@ -222,9 +179,9 @@ export abstract class AbstractGraph<
 
   addEdge(edge: EO): boolean;
 
-  addEdge(src: VO | VertexKey, dest: VO | VertexKey, weight?: number, val?: E): boolean;
+  addEdge(src: VO | VertexKey, dest: VO | VertexKey, weight?: number, value?: E): boolean;
 
-  addEdge(srcOrEdge: VO | VertexKey | EO, dest?: VO | VertexKey, weight?: number, val?: E): boolean {
+  addEdge(srcOrEdge: VO | VertexKey | EO, dest?: VO | VertexKey, weight?: number, value?: E): boolean {
     if (srcOrEdge instanceof AbstractEdge) {
       return this._addEdgeOnly(srcOrEdge);
     } else {
@@ -232,7 +189,7 @@ export abstract class AbstractGraph<
         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, val);
+        const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
         return this._addEdgeOnly(newEdge);
       } else {
         throw new Error('dest must be a Vertex or vertex key while srcOrEdge is an Edge');
@@ -493,10 +450,10 @@ export abstract class AbstractGraph<
     const getMinOfNoSeen = () => {
       let min = Infinity;
       let minV: VO | null = null;
-      for (const [key, val] of distMap) {
+      for (const [key, value] of distMap) {
         if (!seen.has(key)) {
-          if (val < min) {
-            min = val;
+          if (value < min) {
+            min = value;
             minV = key;
           }
         }
@@ -556,14 +513,14 @@ export abstract class AbstractGraph<
     }
 
     getMinDist &&
-      distMap.forEach((d, v) => {
-        if (v !== srcVertex) {
-          if (d < minDist) {
-            minDist = d;
-            if (genPaths) minDest = v;
-          }
+    distMap.forEach((d, v) => {
+      if (v !== srcVertex) {
+        if (d < minDist) {
+          minDist = d;
+          if (genPaths) minDest = v;
         }
-      });
+      }
+    });
 
     genPaths && getPaths(minDest);
 
@@ -625,8 +582,8 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{key: number; val: VO}>({comparator: (a, b) => a.key - b.key});
-    heap.add({key: 0, val: srcVertex});
+    const heap = new PriorityQueue<{ key: number; value: VO }>({comparator: (a, b) => a.key - b.key});
+    heap.add({key: 0, value: srcVertex});
 
     distMap.set(srcVertex, 0);
     preMap.set(srcVertex, null);
@@ -656,7 +613,7 @@ export abstract class AbstractGraph<
     while (heap.size > 0) {
       const curHeapNode = heap.poll();
       const dist = curHeapNode?.key;
-      const cur = curHeapNode?.val;
+      const cur = curHeapNode?.value;
       if (dist !== undefined) {
         if (cur) {
           seen.add(cur);
@@ -677,7 +634,7 @@ export abstract class AbstractGraph<
                 const distSrcToNeighbor = distMap.get(neighbor);
                 if (distSrcToNeighbor) {
                   if (dist + weight < distSrcToNeighbor) {
-                    heap.add({key: dist + weight, val: neighbor});
+                    heap.add({key: dist + weight, value: neighbor});
                     preMap.set(neighbor, cur);
                     distMap.set(neighbor, dist + weight);
                   }
@@ -854,7 +811,7 @@ export abstract class AbstractGraph<
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floyd(): {costs: number[][]; predecessor: (VO | null)[][]} {
+  floyd(): { costs: number[][]; predecessor: (VO | null)[][] } {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
@@ -1040,7 +997,4 @@ export abstract class AbstractGraph<
     return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
   }
 
-  protected _setVertices(value: Map<VertexKey, VO>) {
-    this._vertices = value;
-  }
 }

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

@@ -15,15 +15,18 @@ 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<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,45 +35,24 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
    * @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 {E} [val] - The `val` parameter is an optional parameter of type `E`. 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?: E) {
-    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 = any,
-    E = any,
-    VO extends DirectedVertex<V> = DirectedVertex<V>,
-    EO extends DirectedEdge<E> = DirectedEdge<E>
-  >
+  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>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor function initializes an instance of a class.
    */
@@ -78,13 +60,13 @@ export class DirectedGraph<
     super();
   }
 
-  private _outEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
+  protected _outEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
   get outEdgeMap(): Map<VO, EO[]> {
     return this._outEdgeMap;
   }
 
-  private _inEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
+  protected _inEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
   get inEdgeMap(): Map<VO, EO[]> {
     return this._inEdgeMap;
@@ -99,13 +81,13 @@ export class DirectedGraph<
    * 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 VO.
    */
-  createVertex(key: VertexKey, val?: V): VO {
-    return new DirectedVertex(key, val ?? key) as VO;
+  createVertex(key: VertexKey, value?: V): VO {
+    return new DirectedVertex(key, value ?? key) as VO;
   }
 
   /**
@@ -119,23 +101,23 @@ export class DirectedGraph<
    * @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 EO.
    */
-  createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E): EO {
-    return new DirectedEdge(src, dest, weight ?? 1, val) as EO;
+  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 {VO | null | VertexKey} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-   * @param {VO | null | VertexKey} destOrKey - The `destOrKey` parameter in the `getEdge` function represents 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: VO | null | VertexKey, destOrKey: VO | null | VertexKey): EO | null {
+  getEdge(srcOrKey: VO | VertexKey | null, destOrKey: VO | VertexKey | null): EO | null {
     let edges: EO[] = [];
 
     if (srcOrKey !== null && destOrKey !== null) {
@@ -464,12 +446,4 @@ export class DirectedGraph<
       return false;
     }
   }
-
-  protected _setOutEdgeMap(value: Map<VO, EO[]>) {
-    this._outEdgeMap = value;
-  }
-
-  protected _setInEdgeMap(value: Map<VO, EO[]>) {
-    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,33 +14,13 @@ 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, val: V, lat: number, long: number) {
-    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;
   }
 }
 
@@ -49,11 +32,11 @@ export class MapEdge<E = any> extends DirectedEdge<E> {
    * 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 {E} [val] - The "val" parameter is an optional parameter of type E. 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?: E) {
-    super(src, dest, weight, val);
+  constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E) {
+    super(src, dest, weight, value);
   }
 }
 
@@ -78,39 +61,31 @@ export class MapGraph<
     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`, which means it should be of the same type as the `val` property of the vertex class `VO`.
+   * @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 `VO`.
    */
-  override createVertex(key: VertexKey, val?: V, lat: number = this.origin[0], long: number = this.origin[1]): VO {
-    return new MapVertex(key, val, lat, long) as VO;
+  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;
   }
 
   /**
@@ -121,11 +96,11 @@ export class MapGraph<
    * @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, cast as type `EO`.
    */
-  override createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E): EO {
-    return new MapEdge(src, dest, weight, val) as EO;
+  override createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
+    return new MapEdge(src, dest, weight, value) as EO;
   }
 }

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

@@ -15,15 +15,17 @@ export class UndirectedVertex<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 network.
-   * @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 UndirectedEdge<E = number> extends AbstractEdge<E> {
+  vertices: [VertexKey, VertexKey];
+
   /**
    * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
    * value.
@@ -31,34 +33,23 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
    * @param {VertexKey} v2 - The parameter `v2` is a `VertexKey`, which represents the identifier of the second vertex in a
    * graph edge.
    * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-   * @param {E} [val] - The "val" parameter is an optional parameter of type E. It is used to store a value associated
+   * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store a value associated
    * with the edge.
    */
-  constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: E) {
-    super(weight, val);
-    this._vertices = [v1, v2];
-  }
-
-  private _vertices: [VertexKey, VertexKey];
-
-  get vertices() {
-    return this._vertices;
-  }
-
-  set vertices(v: [VertexKey, VertexKey]) {
-    this._vertices = v;
+  constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
+    super(weight, value);
+    this.vertices = [v1, v2];
   }
 }
 
 export class UndirectedGraph<
-    V = any,
-    E = any,
-    VO extends UndirectedVertex<V> = UndirectedVertex<V>,
-    EO extends UndirectedEdge<E> = UndirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends UndirectedVertex<V> = UndirectedVertex<V>,
+  EO extends UndirectedEdge<E> = UndirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor initializes a new Map object to store edges.
    */
@@ -77,13 +68,13 @@ export class UndirectedGraph<
    * 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 used to distinguish one
    * vertex from another in the graph.
-   * @param [val] - The `val` parameter is an optional value that can be assigned to the vertex. If a value is provided,
+   * @param [value] - The `value` parameter is an optional value that can be assigned to the vertex. If a value is provided,
    * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
    * the vertex.
    * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `VO`.
    */
-  override createVertex(key: VertexKey, val?: VO['val']): VO {
-    return new UndirectedVertex(key, val ?? key) as VO;
+  override createVertex(key: VertexKey, value?: VO['value']): VO {
+    return new UndirectedVertex(key, value ?? key) as VO;
   }
 
   /**
@@ -92,23 +83,23 @@ export class UndirectedGraph<
    * @param {VertexKey} v2 - The parameter `v2` represents the second vertex of 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 the `UndirectedEdge` class, which is casted as type `EO`.
    */
-  override createEdge(v1: VertexKey, v2: VertexKey, weight?: number, val?: EO['val']): EO {
-    return new UndirectedEdge(v1, v2, weight ?? 1, val) as EO;
+  override createEdge(v1: VertexKey, v2: VertexKey, weight?: number, value?: EO['value']): EO {
+    return new UndirectedEdge(v1, v2, weight ?? 1, value) as EO;
   }
 
   /**
    * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-   * @param {VO | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
+   * @param {VO | VertexKey | null} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
    * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
-   * @param {VO | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
+   * @param {VO | VertexKey | null} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
    * object), `null`, or `VertexKey` (vertex ID).
    * @returns an edge (EO) or null.
    */
-  getEdge(v1: VO | null | VertexKey, v2: VO | null | VertexKey): EO | null {
+  getEdge(v1: VO | VertexKey | null, v2: VO | VertexKey | null): EO | null {
     let edges: EO[] | undefined = [];
 
     if (v1 !== null && v2 !== null) {
@@ -265,12 +256,4 @@ export class UndirectedGraph<
     }
     return true;
   }
-
-  /**
-   * The function sets the edges of a graph.
-   * @param v - A map where the keys are of type VO and the values are arrays of type EO.
-   */
-  protected _setEdges(v: Map<VO, EO[]>) {
-    this._edges = v;
-  }
 }

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

@@ -60,8 +60,4 @@ export class CoordinateMap<V> extends Map<any, V> {
   override delete(key: number[]) {
     return super.delete(key.join(this._joint));
   }
-
-  protected _setJoint(v: string) {
-    this._joint = v;
-  }
 }