data-structure-typed 1.48.4 → 1.48.5

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

@@ -24,7 +24,7 @@ export class UndirectedVertex<V = any> extends AbstractVertex<V> {
 }
 
 export class UndirectedEdge<E = number> extends AbstractEdge<E> {
-  vertices: [VertexKey, VertexKey];
+  vertexMap: [VertexKey, VertexKey];
 
   /**
    * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
@@ -38,7 +38,7 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
    */
   constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
     super(weight, value);
-    this.vertices = [v1, v2];
+    this.vertexMap = [v1, v2];
   }
 }
 
@@ -51,17 +51,17 @@ export class UndirectedGraph<
   extends AbstractGraph<V, E, VO, EO>
   implements IGraph<V, E, VO, EO> {
   /**
-   * The constructor initializes a new Map object to store edges.
+   * The constructor initializes a new Map object to store edgeMap.
    */
   constructor() {
     super();
-    this._edges = new Map<VO, EO[]>();
+    this._edgeMap = new Map<VO, EO[]>();
   }
 
-  protected _edges: Map<VO, EO[]>;
+  protected _edgeMap: Map<VO, EO[]>;
 
-  get edges(): Map<VO, EO[]> {
-    return this._edges;
+  get edgeMap(): Map<VO, EO[]> {
+    return this._edgeMap;
   }
 
   /**
@@ -78,7 +78,7 @@ export class UndirectedGraph<
   }
 
   /**
-   * The function creates an undirected edge between two vertices with an optional weight and value.
+   * The function creates an undirected edge between two vertexMap with an optional weight and value.
    * @param {VertexKey} v1 - The parameter `v1` represents the first vertex of the edge.
    * @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
@@ -92,15 +92,15 @@ export class UndirectedGraph<
   }
 
   /**
-   * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+   * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+   * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
    * Space Complexity: O(1)
    *
-   * The function `getEdge` returns the first edge that connects two vertices, or undefined if no such edge exists.
+   * The function `getEdge` returns the first edge that connects two vertexMap, or undefined if no such edge exists.
    * @param {VO | VertexKey | undefined} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
    * object), `undefined`, or `VertexKey` (a string or number representing the ID of a vertex).
    * @param {VO | VertexKey | undefined} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
@@ -108,34 +108,34 @@ export class UndirectedGraph<
    * @returns an edge (EO) or undefined.
    */
   getEdge(v1: VO | VertexKey | undefined, v2: VO | VertexKey | undefined): EO | undefined {
-    let edges: EO[] | undefined = [];
+    let edgeMap: EO[] | undefined = [];
 
     if (v1 !== undefined && v2 !== undefined) {
       const vertex1: VO | undefined = this._getVertex(v1);
       const vertex2: VO | undefined = this._getVertex(v2);
 
       if (vertex1 && vertex2) {
-        edges = this._edges.get(vertex1)?.filter(e => e.vertices.includes(vertex2.key));
+        edgeMap = this._edgeMap.get(vertex1)?.filter(e => e.vertexMap.includes(vertex2.key));
       }
     }
 
-    return edges ? edges[0] || undefined : undefined;
+    return edgeMap ? edgeMap[0] || undefined : undefined;
   }
 
   /**
-   * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+   * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+   * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
    * Space Complexity: O(1)
    *
-   * The function removes an edge between two vertices in a graph and returns the removed edge.
+   * The function removes an edge between two vertexMap in a graph and returns the removed edge.
    * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
    * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
    * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-   * @returns the removed edge (EO) if it exists, or undefined if either of the vertices (VO) does not exist.
+   * @returns the removed edge (EO) if it exists, or undefined if either of the vertexMap (VO) does not exist.
    */
   deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | undefined {
     const vertex1: VO | undefined = this._getVertex(v1);
@@ -145,29 +145,29 @@ export class UndirectedGraph<
       return undefined;
     }
 
-    const v1Edges = this._edges.get(vertex1);
+    const v1Edges = this._edgeMap.get(vertex1);
     let removed: EO | undefined = undefined;
     if (v1Edges) {
-      removed = arrayRemove<EO>(v1Edges, (e: EO) => e.vertices.includes(vertex2.key))[0] || undefined;
+      removed = arrayRemove<EO>(v1Edges, (e: EO) => e.vertexMap.includes(vertex2.key))[0] || undefined;
     }
-    const v2Edges = this._edges.get(vertex2);
+    const v2Edges = this._edgeMap.get(vertex2);
     if (v2Edges) {
-      arrayRemove<EO>(v2Edges, (e: EO) => e.vertices.includes(vertex1.key));
+      arrayRemove<EO>(v2Edges, (e: EO) => e.vertexMap.includes(vertex1.key));
     }
     return removed;
   }
 
   /**
-   * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
+   * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
    * Space Complexity: O(1)
    */
 
 
   /**
-   * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
+   * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
    * Space Complexity: O(1)
    *
-   * The function `deleteEdge` deletes an edge between two vertices in a graph.
+   * The function `deleteEdge` deletes an edge between two vertexMap in a graph.
    * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
    * either an edge object or a vertex key.
    * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
@@ -186,8 +186,8 @@ export class UndirectedGraph<
         return;
       }
     } else {
-      oneSide = this._getVertex(edgeOrOneSideVertexKey.vertices[0]);
-      otherSide = this._getVertex(edgeOrOneSideVertexKey.vertices[1]);
+      oneSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[0]);
+      otherSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[1]);
     }
 
     if (oneSide && otherSide) {
@@ -227,19 +227,19 @@ export class UndirectedGraph<
 
     if (vertex) {
       neighbors.forEach(neighbor => {
-        const neighborEdges = this._edges.get(neighbor);
+        const neighborEdges = this._edgeMap.get(neighbor);
         if (neighborEdges) {
           const restEdges = neighborEdges.filter(edge => {
-            return !edge.vertices.includes(vertexKey);
+            return !edge.vertexMap.includes(vertexKey);
           });
-          this._edges.set(neighbor, restEdges);
+          this._edgeMap.set(neighbor, restEdges);
         }
       })
-      this._edges.delete(vertex);
+      this._edgeMap.delete(vertex);
 
     }
 
-    return this._vertices.delete(vertexKey);
+    return this._vertexMap.delete(vertexKey);
   }
 
   /**
@@ -251,16 +251,16 @@ export class UndirectedGraph<
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
+   * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edgeMap connected to that
    * vertex.
    * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
    * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
-   * edges connected to that vertex.
+   * edgeMap connected to that vertex.
    */
   degreeOf(vertexOrKey: VertexKey | VO): number {
     const vertex = this._getVertex(vertexOrKey);
     if (vertex) {
-      return this._edges.get(vertex)?.length || 0;
+      return this._edgeMap.get(vertex)?.length || 0;
     } else {
       return 0;
     }
@@ -275,36 +275,36 @@ export class UndirectedGraph<
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function returns the edges of a given vertex or vertex ID.
+   * The function returns the edgeMap of a given vertex or vertex ID.
    * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`. A `VertexKey` is a
    * unique identifier for a vertex in a graph, while `VO` represents the type of the vertex.
-   * @returns an array of edges.
+   * @returns an array of edgeMap.
    */
   edgesOf(vertexOrKey: VertexKey | VO): EO[] {
     const vertex = this._getVertex(vertexOrKey);
     if (vertex) {
-      return this._edges.get(vertex) || [];
+      return this._edgeMap.get(vertex) || [];
     } else {
       return [];
     }
   }
 
   /**
-   * Time Complexity: O(|V| + |E|), where |V| is the number of vertices and |E| is the number of edges.
+   * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
    * Space Complexity: O(|E|)
    */
 
   /**
-   * Time Complexity: O(|V| + |E|), where |V| is the number of vertices and |E| is the number of edges.
+   * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
    * Space Complexity: O(|E|)
    *
-   * The function "edgeSet" returns an array of unique edges from a set of edges.
+   * The function "edgeSet" returns an array of unique edgeMap from a set of edgeMap.
    * @returns The method `edgeSet()` returns an array of type `EO[]`.
    */
   edgeSet(): EO[] {
     const edgeSet: Set<EO> = new Set();
-    this._edges.forEach(edges => {
-      edges.forEach(edge => {
+    this._edgeMap.forEach(edgeMap => {
+      edgeMap.forEach(edge => {
         edgeSet.add(edge);
       });
     });
@@ -312,18 +312,18 @@ export class UndirectedGraph<
   }
 
   /**
-   * Time Complexity: O(|V| + |E|), where |V| is the number of vertices and |E| is the number of edges.
+   * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
    * Space Complexity: O(|E|)
    */
 
   /**
-   * Time Complexity: O(|V| + |E|), where |V| is the number of vertices and |E| is the number of edges.
+   * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
    * Space Complexity: O(|E|)
    *
-   * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
+   * The function "getNeighbors" returns an array of neighboring vertexMap for a given vertex or 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 (VO[]).
+   * @returns an array of vertexMap (VO[]).
    */
   getNeighbors(vertexOrKey: VO | VertexKey): VO[] {
     const neighbors: VO[] = [];
@@ -331,7 +331,7 @@ export class UndirectedGraph<
     if (vertex) {
       const neighborEdges = this.edgesOf(vertex);
       for (const edge of neighborEdges) {
-        const neighbor = this._getVertex(edge.vertices.filter(e => e !== vertex.key)[0]);
+        const neighbor = this._getVertex(edge.vertexMap.filter(e => e !== vertex.key)[0]);
         if (neighbor) {
           neighbors.push(neighbor);
         }
@@ -349,18 +349,18 @@ export class UndirectedGraph<
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
+   * The function "getEndsOfEdge" returns the vertexMap at the ends of an edge if the edge exists in the graph, otherwise
    * it returns undefined.
    * @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
+   * @returns The function `getEndsOfEdge` returns an array containing two vertexMap `[VO, VO]` if the edge exists in the
    * graph. If the edge does not exist, it returns `undefined`.
    */
   getEndsOfEdge(edge: EO): [VO, VO] | undefined {
-    if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
+    if (!this.hasEdge(edge.vertexMap[0], edge.vertexMap[1])) {
       return undefined;
     }
-    const v1 = this._getVertex(edge.vertices[0]);
-    const v2 = this._getVertex(edge.vertices[1]);
+    const v1 = this._getVertex(edge.vertexMap[0]);
+    const v2 = this._getVertex(edge.vertexMap[1]);
     if (v1 && v2) {
       return [v1, v2];
     } else {
@@ -377,20 +377,20 @@ export class UndirectedGraph<
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function adds an edge to the graph by updating the adjacency list with the vertices of the edge.
+   * The function adds an edge to the graph by updating the adjacency list with the vertexMap of the edge.
    * @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 {
-    for (const end of edge.vertices) {
+    for (const end of edge.vertexMap) {
       const endVertex = this._getVertex(end);
       if (endVertex === undefined) return false;
       if (endVertex) {
-        const edges = this._edges.get(endVertex);
-        if (edges) {
-          edges.push(edge);
+        const edgeMap = this._edgeMap.get(endVertex);
+        if (edgeMap) {
+          edgeMap.push(edge);
         } else {
-          this._edges.set(endVertex, [edge]);
+          this._edgeMap.set(endVertex, [edge]);
         }
       }
     }

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

@@ -7,10 +7,10 @@
  */
 
 import { isWeakKey, rangeCheck } from '../../utils';
-import { HashMapLinkedNode, HashMapOptions, HashMapStoreItem, PairCallback } from '../../types';
-import { IterablePairBase } from "../base";
+import { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import { IterableEntryBase } from "../base";
 
-export class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
+export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   protected _store: { [key: string]: HashMapStoreItem<K, V> } = {};
   protected _objMap: Map<object, V> = new Map();
 
@@ -165,7 +165,7 @@ export class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
    * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
    * the provided callback function.
    */
-  map<U>(callbackfn: PairCallback<K, V, U>, thisArg?: any): HashMap<K, U> {
+  map<U>(callbackfn: EntryCallback<K, V, U>, thisArg?: any): HashMap<K, U> {
     const resultMap = new HashMap<K, U>();
     let index = 0;
     for (const [key, value] of this) {
@@ -195,7 +195,7 @@ export class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
    * @returns The `filter` method is returning a new `HashMap` object that contains the key-value pairs
    * from the original `HashMap` that pass the provided `predicate` function.
    */
-  filter(predicate: PairCallback<K, V, boolean>, thisArg?: any): HashMap<K, V> {
+  filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): HashMap<K, V> {
     const filteredMap = new HashMap<K, V>();
     let index = 0;
     for (const [key, value] of this) {
@@ -248,7 +248,7 @@ export class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
   }
 }
 
-export class LinkedHashMap<K = any, V = any> extends IterablePairBase<K, V> {
+export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
 
   protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
   protected _objMap = new WeakMap<object, HashMapLinkedNode<K, V | undefined>>();
@@ -567,7 +567,7 @@ export class LinkedHashMap<K = any, V = any> extends IterablePairBase<K, V> {
    * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
    * `LinkedHashMap` object that satisfy the given predicate function.
    */
-  filter(predicate: PairCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V> {
+  filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V> {
     const filteredMap = new LinkedHashMap<K, V>();
     let index = 0;
     for (const [key, value] of this) {
@@ -601,7 +601,7 @@ export class LinkedHashMap<K = any, V = any> extends IterablePairBase<K, V> {
    * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
    * function.
    */
-  map<NV>(callback: PairCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV> {
+  map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV> {
     const mappedMap = new LinkedHashMap<K, NV>();
     let index = 0;
     for (const [key, value] of this) {

package/src/interfaces/binary-tree.ts

@@ -13,7 +13,7 @@ export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V,
 
   createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
 
-  add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, count?: number): N | null | undefined;
+  add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
 
   addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[];
 

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

@@ -1,6 +1,6 @@
-import { IterableElementBase, IterablePairBase } from "../../../data-structures";
+import { IterableElementBase, IterableEntryBase } from "../../../data-structures";
 
-export type PairCallback<K, V, R> = (value: V, key: K, index: number, container: IterablePairBase<K, V>) => R;
+export type EntryCallback<K, V, R> = (value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
 export type ElementCallback<V, R> = (element: V, index: number, container: IterableElementBase<V>) => R;
-export type ReducePairCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterablePairBase<K, V>) => R;
+export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
 export type ReduceElementCallback<V, R> = (accumulator: R, element: V, index: number, container: IterableElementBase<V>) => R;

package/test/integration/bst.test.ts

@@ -183,7 +183,7 @@ describe('Individual package BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<number,{ key: number; keyA: number }>();
+    const objBST = new BST<number, { key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add([11, { key: 11, keyA: 11 }]);
     objBST.add([3, { key: 3, keyA: 3 }]);

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -569,7 +569,7 @@ describe('BinaryTree iterative methods test', () => {
   beforeEach(() => {
     binaryTree = new BinaryTree();
     binaryTree.add([1, 'a']);
-    binaryTree.add([2, 'b']);
+    binaryTree.add(2, 'b');
     binaryTree.add([3, 'c']);
   });
 

package/test/unit/data-structures/binary-tree/tree-multimap.test.ts

@@ -605,9 +605,9 @@ describe('TreeMultimap iterative methods test', () => {
   let treeMM: TreeMultimap<number, string>;
   beforeEach(() => {
     treeMM = new TreeMultimap<number, string>();
-    treeMM.add([1, 'a'], 10);
-    treeMM.add([2, 'b'], 10);
-    treeMM.add([3, 'c'], 1);
+    treeMM.add(1, 'a', 10);
+    treeMM.add([2, 'b'], undefined, 10);
+    treeMM.add([3, 'c'], undefined, 1);
   });
 
   test('The node obtained by get Node should match the node type', () => {

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -7,7 +7,7 @@ describe('DirectedGraph Operation Test', () => {
     graph = new DirectedGraph();
   });
 
-  it('should add vertices', () => {
+  it('should add vertexMap', () => {
     const vertex1 = new DirectedVertex('A');
     const vertex2 = new DirectedVertex('B');
 
@@ -155,7 +155,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     myGraph = new MyDirectedGraph();
   });
 
-  it('Add vertices', () => {
+  it('Add vertexMap', () => {
     myGraph.addVertex(1, 'data1');
     myGraph.addVertex(2, 'data2');
     myGraph.addVertex(3, 'data3');
@@ -204,7 +204,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     expect(true).toBeTruthy();
   });
 
-  it('Remove edge between vertices', () => {
+  it('Remove edge between vertexMap', () => {
     myGraph.addVertex(1, 'data1');
     myGraph.addVertex(2, 'data2');
     myGraph.addEdge(1, 2, 10, 'edge-data1-2');
@@ -232,14 +232,14 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     }
   });
 
-  it('Minimum path between vertices', () => {
+  it('Minimum path between vertexMap', () => {
     myGraph.addVertex(new MyVertex(1, 'data1'));
     myGraph.addVertex(new MyVertex(2, 'data2'));
     myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
   });
 
-  it('All paths between vertices', () => {
-    // Add vertices and edges as needed for this test
+  it('All paths between vertexMap', () => {
+    // Add vertexMap and edges as needed for this test
     myGraph.addVertex(new MyVertex(1, 'data1'));
     myGraph.addVertex(new MyVertex(2, 'data2'));
     myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
@@ -598,41 +598,41 @@ describe('cycles, strongly connected components, bridges, articular points in Di
 
 describe('DirectedGraph iterative Methods', () => {
   let graph: DirectedGraph<string>;
-  let vertices: string[];
+  let vertexMap: string[];
 
   beforeEach(() => {
     graph = new DirectedGraph();
-    vertices = ['A', 'B', 'C', 'D'];
-    vertices.forEach(vertex => graph.addVertex(vertex));
+    vertexMap = ['A', 'B', 'C', 'D'];
+    vertexMap.forEach(vertex => graph.addVertex(vertex));
   });
 
-  test('[Symbol.iterator] should iterate over all vertices', () => {
+  test('[Symbol.iterator] should iterate over all vertexMap', () => {
     const iteratedVertices = [];
     for (const vertex of graph) {
       iteratedVertices.push(vertex[0]);
     }
-    expect(iteratedVertices).toEqual(vertices);
+    expect(iteratedVertices).toEqual(vertexMap);
   });
 
   test('forEach should apply a function to each vertex', () => {
     const result: VertexKey[] = [];
     graph.forEach((value, key) => key && result.push(key));
-    expect(result).toEqual(vertices);
+    expect(result).toEqual(vertexMap);
   });
 
-  test('filter should return vertices that satisfy the condition', () => {
+  test('filter should return vertexMap that satisfy the condition', () => {
     const filtered = graph.filter((value, vertex) => vertex === 'A' || vertex === 'B');
     expect(filtered).toEqual([["A", undefined], ["B", undefined]]);
   });
 
   test('map should apply a function to each vertex and return a new array', () => {
     const mapped = graph.map((value, vertex) => vertex + '_mapped');
-    expect(mapped).toEqual(vertices.map(v => v + '_mapped'));
+    expect(mapped).toEqual(vertexMap.map(v => v + '_mapped'));
   });
 
   test('reduce should accumulate a value based on each vertex', () => {
     const concatenated = graph.reduce((acc, value, key) => acc + key, '');
-    expect(concatenated).toBe(vertices.join(''));
+    expect(concatenated).toBe(vertexMap.join(''));
   });
 
   test('Removing an edge of a DirectedGraph should not delete additional edges', () => {

package/test/unit/data-structures/graph/map-graph.test.ts

@@ -52,8 +52,8 @@ describe('MapGraph', () => {
     mapGraph = new MapGraph<string, string>([0, 0], [100, 100]);
   });
 
-  // Test adding vertices to the graph
-  it('should add vertices to the graph', () => {
+  // Test adding vertexMap to the graph
+  it('should add vertexMap to the graph', () => {
     const locationA = new MapVertex('A', 'Location A', 10, 20);
     const locationB = new MapVertex('B', 'Location B', 30, 40);
 
@@ -88,7 +88,7 @@ describe('MapGraph', () => {
     const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
     const edgeBC = new MapEdge('B', 'C', 60, 'Edge from B to C');
 
-    expect(mapGraph.origin).toEqual([0, 0]);
+    expect(mapGraph.originCoord).toEqual([0, 0]);
     expect(mapGraph.bottomRight).toEqual([100, 100]);
 
     mapGraph.addVertex(locationA);

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -17,7 +17,7 @@ describe('UndirectedGraph Operation Test', () => {
     expect(graph.getEndsOfEdge(new UndirectedEdge('c', 'd'))).toBe(undefined);
   });
 
-  it('should add vertices', () => {
+  it('should add vertexMap', () => {
     const vertex1 = new UndirectedVertex('A');
     const vertex2 = new UndirectedVertex('B');
 
@@ -76,8 +76,8 @@ describe('UndirectedGraph', () => {
     undirectedGraph = new UndirectedGraph<string, string>();
   });
 
-  // Test adding vertices to the graph
-  it('should add vertices to the graph', () => {
+  // Test adding vertexMap to the graph
+  it('should add vertexMap to the graph', () => {
     const vertexA = new UndirectedVertex('A', 'Location A');
     const vertexB = new UndirectedVertex('B', 'Location B');
 
@@ -130,8 +130,8 @@ describe('UndirectedGraph', () => {
     const edgeAB = new UndirectedEdge('A', 'B', 3, 'Edge between A and B');
     const edgeBC = new UndirectedEdge('B', 'C', 4, 'Edge between B and C');
 
-    edgeAB.vertices = edgeAB.vertices;
-    expect(undirectedGraph.edges.size).toBe(0);
+    edgeAB.vertexMap = edgeAB.vertexMap;
+    expect(undirectedGraph.edgeMap.size).toBe(0);
     undirectedGraph.addVertex(vertexA);
     undirectedGraph.addVertex(vertexB);
     undirectedGraph.addVertex(vertexC);
@@ -181,10 +181,10 @@ describe('UndirectedGraph', () => {
     dg.addVertex('hey')
     dg.addEdge('hello', 'hi')
     dg.addEdge('hello', 'hey')
-    expect(dg.getEdge('hello', 'hi')?.vertices[0]).toBe('hello')
-    expect(dg.getEdge('hello', 'hi')?.vertices[1]).toBe('hi')
-    expect(dg.getEdge('hello', 'hey')?.vertices[0]).toBe('hello')
-    expect(dg.getEdge('hello', 'hey')?.vertices[1]).toBe('hey')
+    expect(dg.getEdge('hello', 'hi')?.vertexMap[0]).toBe('hello')
+    expect(dg.getEdge('hello', 'hi')?.vertexMap[1]).toBe('hi')
+    expect(dg.getEdge('hello', 'hey')?.vertexMap[0]).toBe('hello')
+    expect(dg.getEdge('hello', 'hey')?.vertexMap[1]).toBe('hey')
     dg.deleteEdge('hello', 'hi')
     expect(dg.getEdge('hello', 'hi')).toBe(undefined)
     expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(UndirectedEdge)
@@ -200,13 +200,13 @@ describe('UndirectedGraph', () => {
     dg.addEdge('hello', 'earth')
     dg.addEdge('world', 'earth')
 
-    expect(dg.getEdge('hello', 'world')?.vertices[0]).toBe('hello');
+    expect(dg.getEdge('hello', 'world')?.vertexMap[0]).toBe('hello');
     expect(dg.edgeSet().length).toBe(3)
-    expect(dg.edgeSet()[0].vertices).toEqual(['hello', 'world'])
+    expect(dg.edgeSet()[0].vertexMap).toEqual(['hello', 'world'])
 
     dg.deleteVertex('hello')
     expect(dg.edgeSet().length).toBe(1)
-    expect(dg.edgeSet()?.[0].vertices[0]).toBe('world')
+    expect(dg.edgeSet()?.[0].vertexMap[0]).toBe('world')
 
     expect(dg.getEdge('hello', 'world')).toBe(undefined);
   })