data-structure-typed 1.34.6 → 1.34.8

package/lib/data-structures/graph/directed-graph.js

@@ -10,23 +10,23 @@ import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 export class DirectedVertex extends AbstractVertex {
     /**
      * The constructor function initializes a vertex with an optional value.
-     * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
+     * @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
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(id, val) {
-        super(id, val);
+    constructor(key, val) {
+        super(key, val);
     }
 }
 export class DirectedEdge extends AbstractEdge {
     /**
      * The constructor function initializes the source and destination vertices of an edge, along with an optional weight
      * and value.
-     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * @param {VertexKey} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
      * a graph.
-     * @param {VertexId} dest - The `dest` parameter represents the destination vertex of an edge. It is of type
-     * `VertexId`, which is likely a unique identifier for a vertex in a graph.
+     * @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
      * the edge.
@@ -70,15 +70,15 @@ export class DirectedGraph extends AbstractGraph {
      */
     /**
      * The function creates a new vertex with an optional value and returns it.
-     * @param {VertexId} id - The `id` parameter is the unique identifier for the vertex. It is of type `VertexId`, which
+     * @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
-     * assigned the same value as the 'id' parameter
+     * assigned the same value as the 'key' parameter
      * @returns a new instance of a DirectedVertex object, casted as type V.
      */
-    createVertex(id, val) {
-        return new DirectedVertex(id, val !== null && val !== void 0 ? val : id);
+    createVertex(key, val) {
+        return new DirectedVertex(key, val !== null && val !== void 0 ? val : key);
     }
     /**
      * 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.
@@ -86,8 +86,8 @@ export class DirectedGraph extends AbstractGraph {
      */
     /**
      * The function creates a directed edge between two vertices with an optional weight and value.
-     * @param {VertexId} src - The source vertex ID of the edge. It represents the starting point of the edge.
-     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for the edge.
+     * @param {VertexKey} src - The source vertex ID of the edge. It represents the starting point of the edge.
+     * @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
@@ -99,21 +99,21 @@ export class DirectedGraph extends AbstractGraph {
     }
     /**
      * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-     * @param {V | null | VertexId} srcOrId - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-     * @param {V | null | VertexId} destOrId - The `destOrId` parameter in the `getEdge` function represents the
-     * destination vertex of the edge. It can be either a vertex object (`V`), a vertex ID (`VertexId`), or `null` if the
+     * @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
      * destination is not specified.
      * @returns the first edge found between the source and destination vertices, or null if no such edge is found.
      */
-    getEdge(srcOrId, destOrId) {
+    getEdge(srcOrKey, destOrKey) {
         let edges = [];
-        if (srcOrId !== null && destOrId !== null) {
-            const src = this._getVertex(srcOrId);
-            const dest = this._getVertex(destOrId);
+        if (srcOrKey !== null && destOrKey !== null) {
+            const src = this._getVertex(srcOrKey);
+            const dest = this._getVertex(destOrKey);
             if (src && dest) {
                 const srcOutEdges = this._outEdgeMap.get(src);
                 if (srcOutEdges) {
-                    edges = srcOutEdges.filter(edge => edge.dest === dest.id);
+                    edges = srcOutEdges.filter(edge => edge.dest === dest.key);
                 }
             }
         }
@@ -121,24 +121,24 @@ export class DirectedGraph extends AbstractGraph {
     }
     /**
      * The function removes an edge between two vertices in a graph and returns the removed edge.
-     * @param {V | VertexId} srcOrId - The source vertex or its ID.
-     * @param {V | VertexId} destOrId - The `destOrId` parameter represents the destination vertex or its ID.
+     * @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.
      */
-    removeEdgeSrcToDest(srcOrId, destOrId) {
-        const src = this._getVertex(srcOrId);
-        const dest = this._getVertex(destOrId);
+    removeEdgeSrcToDest(srcOrKey, destOrKey) {
+        const src = this._getVertex(srcOrKey);
+        const dest = this._getVertex(destOrKey);
         let removed = null;
         if (!src || !dest) {
             return null;
         }
         const srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges) {
-            arrayRemove(srcOutEdges, (edge) => edge.dest === dest.id);
+            arrayRemove(srcOutEdges, (edge) => edge.dest === dest.key);
         }
         const destInEdges = this._inEdgeMap.get(dest);
         if (destInEdges) {
-            removed = arrayRemove(destInEdges, (edge) => edge.src === src.id)[0] || null;
+            removed = arrayRemove(destInEdges, (edge) => edge.src === src.key)[0] || null;
         }
         return removed;
     }
@@ -155,20 +155,20 @@ export class DirectedGraph extends AbstractGraph {
         if (src && dest) {
             const srcOutEdges = this._outEdgeMap.get(src);
             if (srcOutEdges && srcOutEdges.length > 0) {
-                arrayRemove(srcOutEdges, (edge) => edge.src === src.id);
+                arrayRemove(srcOutEdges, (edge) => edge.src === src.key);
             }
             const destInEdges = this._inEdgeMap.get(dest);
             if (destInEdges && destInEdges.length > 0) {
-                removed = arrayRemove(destInEdges, (edge) => edge.dest === dest.id)[0];
+                removed = arrayRemove(destInEdges, (edge) => edge.dest === dest.key)[0];
             }
         }
         return removed;
     }
     /**
      * The function removes edges between two vertices and returns the removed edges.
-     * @param {VertexId | V} v1 - The parameter `v1` can be either a `VertexId` or a `V`. A `VertexId` represents the
+     * @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 {VertexId | V} v2 - The parameter `v2` represents either a `VertexId` or a `V` object. It is used to specify
+     * @param {VertexKey | V} v2 - The parameter `v2` represents either a `VertexKey` or a `V` object. It is used to specify
      * the second vertex in the edge that needs to be removed.
      * @returns an array of removed edges (E[]).
      */
@@ -184,12 +184,12 @@ export class DirectedGraph extends AbstractGraph {
     }
     /**
      * The function `incomingEdgesOf` returns an array of incoming edges for a given vertex or vertex ID.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
+     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexKey`).
      * @returns The method `incomingEdgesOf` returns an array of edges (`E[]`).
      */
-    incomingEdgesOf(vertexOrId) {
-        const target = this._getVertex(vertexOrId);
+    incomingEdgesOf(vertexOrKey) {
+        const target = this._getVertex(vertexOrKey);
         if (target) {
             return this.inEdgeMap.get(target) || [];
         }
@@ -197,12 +197,12 @@ export class DirectedGraph extends AbstractGraph {
     }
     /**
      * The function `outgoingEdgesOf` returns an array of outgoing edges from a given vertex or vertex ID.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
+     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can accept either a vertex object (`V`) or a vertex ID
+     * (`VertexKey`).
      * @returns The method `outgoingEdgesOf` returns an array of edges (`E[]`).
      */
-    outgoingEdgesOf(vertexOrId) {
-        const target = this._getVertex(vertexOrId);
+    outgoingEdgesOf(vertexOrKey) {
+        const target = this._getVertex(vertexOrKey);
         if (target) {
             return this._outEdgeMap.get(target) || [];
         }
@@ -210,35 +210,35 @@ export class DirectedGraph extends AbstractGraph {
     }
     /**
      * The function "degreeOf" returns the total degree of a vertex, which is the sum of its out-degree and in-degree.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
      * @returns The sum of the out-degree and in-degree of the specified vertex or vertex ID.
      */
-    degreeOf(vertexOrId) {
-        return this.outDegreeOf(vertexOrId) + this.inDegreeOf(vertexOrId);
+    degreeOf(vertexOrKey) {
+        return this.outDegreeOf(vertexOrKey) + this.inDegreeOf(vertexOrKey);
     }
     /**
      * The function "inDegreeOf" returns the number of incoming edges for a given vertex.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
      * @returns The number of incoming edges of the specified vertex or vertex ID.
      */
-    inDegreeOf(vertexOrId) {
-        return this.incomingEdgesOf(vertexOrId).length;
+    inDegreeOf(vertexOrKey) {
+        return this.incomingEdgesOf(vertexOrKey).length;
     }
     /**
      * The function `outDegreeOf` returns the number of outgoing edges from a given vertex.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
      * @returns The number of outgoing edges from the specified vertex or vertex ID.
      */
-    outDegreeOf(vertexOrId) {
-        return this.outgoingEdgesOf(vertexOrId).length;
+    outDegreeOf(vertexOrKey) {
+        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 {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
      * @returns The function `edgesOf` returns an array of edges.
      */
-    edgesOf(vertexOrId) {
-        return [...this.outgoingEdgesOf(vertexOrId), ...this.incomingEdgesOf(vertexOrId)];
+    edgesOf(vertexOrKey) {
+        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.
@@ -258,8 +258,8 @@ export class DirectedGraph extends AbstractGraph {
     }
     /**
      * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
-     * @param {V | VertexId | 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 `VertexId` value, or `null`.
+     * @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[]).
      */
     getDestinations(vertex) {
@@ -279,13 +279,13 @@ export class DirectedGraph extends AbstractGraph {
     /**
      * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
      * in the sorted order, or null if the graph contains a cycle.
-     * @param {'vertex' | 'id'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
-     * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'id'. If 'vertex' is
-     * specified, the vertices themselves will be used for sorting. If 'id' is specified, the ids of
+     * @param {'vertex' | 'key'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
+     * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'key'. If 'vertex' is
+     * 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) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        propertyName = propertyName !== null && propertyName !== void 0 ? 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 = new Map();
@@ -316,8 +316,8 @@ export class DirectedGraph extends AbstractGraph {
         }
         if (hasCycle)
             return null;
-        if (propertyName === 'id')
-            sorted = sorted.map(vertex => (vertex instanceof DirectedVertex ? vertex.id : vertex));
+        if (propertyName === 'key')
+            sorted = sorted.map(vertex => (vertex instanceof DirectedVertex ? vertex.key : vertex));
         return sorted.reverse();
     }
     /**
@@ -333,13 +333,13 @@ export class DirectedGraph extends AbstractGraph {
     }
     /**
      * The function `getNeighbors` returns an array of neighboring vertices of a given vertex or vertex ID in a graph.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
+     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexKey`).
      * @returns an array of vertices (V[]).
      */
-    getNeighbors(vertexOrId) {
+    getNeighbors(vertexOrKey) {
         const neighbors = [];
-        const vertex = this._getVertex(vertexOrId);
+        const vertex = this._getVertex(vertexOrKey);
         if (vertex) {
             const outEdges = this.outgoingEdgesOf(vertex);
             for (const outEdge of outEdges) {

package/lib/data-structures/graph/map-graph.d.ts

@@ -1,9 +1,9 @@
-import { MapGraphCoordinate, VertexId } from '../../types';
+import { MapGraphCoordinate, VertexKey } from '../../types';
 import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
 export declare class MapVertex<V = any> extends DirectedVertex<V> {
     /**
-     * The constructor function initializes an object with an id, latitude, longitude, and an optional value.
-     * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex.
+     * 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.
      * @param {number} lat - The "lat" parameter represents the latitude of a vertex. Latitude is a geographic coordinate
      * that specifies the north-south position of a point on the Earth's surface. It is measured in degrees, with positive
      * values representing points north of the equator and negative values representing points south of the equator.
@@ -13,7 +13,7 @@ export declare class MapVertex<V = any> extends DirectedVertex<V> {
      * @param {V} [val] - The "val" parameter is an optional value of type V. It is not required to be provided when
      * creating an instance of the class.
      */
-    constructor(id: VertexId, lat: number, long: number, val?: V);
+    constructor(key: VertexKey, lat: number, long: number, val?: V);
     private _lat;
     get lat(): number;
     set lat(value: number);
@@ -25,14 +25,14 @@ export declare class MapEdge<V = any> extends DirectedEdge<V> {
     /**
      * The constructor function initializes a new instance of a class with the given source, destination, weight, and
      * value.
-     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * @param {VertexKey} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
      * a graph.
-     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
+     * @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
      * information or data associated with the edge.
      */
-    constructor(src: VertexId, dest: VertexId, weight?: number, val?: V);
+    constructor(src: VertexKey, dest: VertexKey, weight?: number, val?: V);
 }
 export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEdge = MapEdge> extends DirectedGraph<V, E> {
     /**
@@ -52,8 +52,8 @@ export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E exten
     get bottomRight(): MapGraphCoordinate | undefined;
     set bottomRight(value: MapGraphCoordinate | undefined);
     /**
-     * The function creates a new vertex with the given id, value, latitude, and longitude.
-     * @param {VertexId} id - The id parameter is the unique identifier for the vertex. It is of type VertexId, which could
+     * 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`.
@@ -62,11 +62,11 @@ export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E exten
      * @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`.
      */
-    createVertex(id: VertexId, val?: V['val'], lat?: number, long?: number): V;
+    createVertex(key: VertexKey, val?: V['val'], lat?: number, long?: number): V;
     /**
      * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
-     * @param {VertexId} src - The source vertex ID of the edge. It represents the starting point of the edge.
-     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for the edge being
+     * @param {VertexKey} src - The source vertex ID of the edge. It represents the starting point of the edge.
+     * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for the edge being
      * created.
      * @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.
@@ -75,5 +75,5 @@ export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E exten
      * depending on the specific implementation of the `MapEdge` class.
      * @returns a new instance of the `MapEdge` class, casted as type `E`.
      */
-    createEdge(src: VertexId, dest: VertexId, weight?: number, val?: E['val']): E;
+    createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E['val']): E;
 }

package/lib/data-structures/graph/map-graph.js

@@ -1,8 +1,8 @@
 import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
 export class MapVertex extends DirectedVertex {
     /**
-     * The constructor function initializes an object with an id, latitude, longitude, and an optional value.
-     * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex.
+     * 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.
      * @param {number} lat - The "lat" parameter represents the latitude of a vertex. Latitude is a geographic coordinate
      * that specifies the north-south position of a point on the Earth's surface. It is measured in degrees, with positive
      * values representing points north of the equator and negative values representing points south of the equator.
@@ -12,8 +12,8 @@ export class MapVertex extends DirectedVertex {
      * @param {V} [val] - The "val" parameter is an optional value of type V. It is not required to be provided when
      * creating an instance of the class.
      */
-    constructor(id, lat, long, val) {
-        super(id, val);
+    constructor(key, lat, long, val) {
+        super(key, val);
         this._lat = lat;
         this._long = long;
     }
@@ -34,9 +34,9 @@ export class MapEdge extends DirectedEdge {
     /**
      * The constructor function initializes a new instance of a class with the given source, destination, weight, and
      * value.
-     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * @param {VertexKey} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
      * a graph.
-     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
+     * @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
      * information or data associated with the edge.
@@ -74,8 +74,8 @@ export class MapGraph extends DirectedGraph {
         this._bottomRight = value;
     }
     /**
-     * The function creates a new vertex with the given id, value, latitude, and longitude.
-     * @param {VertexId} id - The id parameter is the unique identifier for the vertex. It is of type VertexId, which could
+     * 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`.
@@ -84,13 +84,13 @@ export class MapGraph extends DirectedGraph {
      * @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`.
      */
-    createVertex(id, val, lat = this.origin[0], long = this.origin[1]) {
-        return new MapVertex(id, lat, long, val);
+    createVertex(key, val, lat = this.origin[0], long = this.origin[1]) {
+        return new MapVertex(key, lat, long, val);
     }
     /**
      * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
-     * @param {VertexId} src - The source vertex ID of the edge. It represents the starting point of the edge.
-     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for the edge being
+     * @param {VertexKey} src - The source vertex ID of the edge. It represents the starting point of the edge.
+     * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for the edge being
      * created.
      * @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.

package/lib/data-structures/graph/undirected-graph.d.ts

@@ -1,31 +1,31 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
-import type { VertexId } from '../../types';
+import type { VertexKey } from '../../types';
 import { IUNDirectedGraph } from '../../interfaces';
 export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     /**
      * The constructor function initializes a vertex with an optional value.
-     * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
+     * @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
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(id: VertexId, val?: V);
+    constructor(key: VertexKey, val?: V);
 }
 export declare class UndirectedEdge<V = number> extends AbstractEdge<V> {
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
-     * @param {VertexId} v1 - The first vertex ID of the edge.
-     * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
+     * @param {VertexKey} v1 - The first vertex ID of the edge.
+     * @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 {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store a value associated
      * with the edge.
      */
-    constructor(v1: VertexId, v2: VertexId, weight?: number, val?: V);
+    constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: V);
     private _vertices;
-    get vertices(): [VertexId, VertexId];
-    set vertices(v: [VertexId, VertexId]);
+    get vertices(): [VertexKey, VertexKey];
+    set vertices(v: [VertexKey, VertexKey]);
 }
 export declare class UndirectedGraph<V extends UndirectedVertex<any> = UndirectedVertex, E extends UndirectedEdge<any> = UndirectedEdge> extends AbstractGraph<V, E> implements IUNDirectedGraph<V, E> {
     /**
@@ -36,42 +36,42 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
     get edges(): Map<V, E[]>;
     /**
      * The function creates a new vertex with an optional value and returns it.
-     * @param {VertexId} id - The `id` parameter is the unique identifier for the vertex. It is used to distinguish one
+     * @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,
-     * it will be used as the value of the vertex. If no value is provided, the `id` parameter will be used as the value of
+     * 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 `V`.
      */
-    createVertex(id: VertexId, val?: V['val']): V;
+    createVertex(key: VertexKey, val?: V['val']): V;
     /**
      * The function creates an undirected edge between two vertices with an optional weight and value.
-     * @param {VertexId} v1 - The parameter `v1` represents the first vertex of the edge.
-     * @param {VertexId} v2 - The parameter `v2` represents the second vertex of the edge.
+     * @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
      * 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
      * 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 `E`.
      */
-    createEdge(v1: VertexId, v2: VertexId, weight?: number, val?: E['val']): E;
+    createEdge(v1: VertexKey, v2: VertexKey, weight?: number, val?: E['val']): E;
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-     * @param {V | null | VertexId} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
-     * object), `null`, or `VertexId` (a string or number representing the ID of a vertex).
-     * @param {V | null | VertexId} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
-     * object), `null`, or `VertexId` (vertex ID).
+     * @param {V | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
+     * @param {V | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * object), `null`, or `VertexKey` (vertex ID).
      * @returns an edge (E) or null.
      */
-    getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null;
+    getEdge(v1: V | null | VertexKey, v2: V | null | VertexKey): E | null;
     /**
      * The function removes an edge between two vertices in a graph and returns the removed edge.
-     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
-     * @param {V | VertexId} v2 - V | VertexId - This parameter can be either a vertex object (V) or a vertex ID
-     * (VertexId). It represents the second vertex of the edge that needs to be removed.
+     * @param {V | VertexKey} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexKey`).
+     * @param {V | VertexKey} v2 - V | VertexKey - This parameter can be either a vertex object (V) or a vertex ID
+     * (VertexKey). It represents the second vertex of the edge that needs to be removed.
      * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
      */
-    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;
+    removeEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null;
     /**
      * The removeEdge function removes an edge between two vertices in a graph.
      * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
@@ -81,18 +81,18 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
     /**
      * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
      * vertex.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
      * @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.
      */
-    degreeOf(vertexOrId: VertexId | V): number;
+    degreeOf(vertexOrKey: VertexKey | V): number;
     /**
      * The function returns the edges of a given vertex or vertex ID.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`. A `VertexId` is a
+     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`. A `VertexKey` is a
      * unique identifier for a vertex in a graph, while `V` represents the type of the vertex.
      * @returns an array of edges.
      */
-    edgesOf(vertexOrId: VertexId | V): E[];
+    edgesOf(vertexOrKey: VertexKey | V): E[];
     /**
      * The function "edgeSet" returns an array of unique edges from a set of edges.
      * @returns The method `edgeSet()` returns an array of type `E[]`.
@@ -100,11 +100,11 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
     edgeSet(): E[];
     /**
      * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
+     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexKey`).
      * @returns an array of vertices (V[]).
      */
-    getNeighbors(vertexOrId: V | VertexId): V[];
+    getNeighbors(vertexOrKey: V | VertexKey): V[];
     /**
      * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
      * it returns null.