data-structure-typed 1.17.4 → 1.18.5

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

@@ -1,111 +1,130 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { VertexId } from '../types';
-export declare class UndirectedVertex extends AbstractVertex {
+export declare class UndirectedVertex<T = number> extends AbstractVertex<T> {
     /**
-     * The constructor function initializes an object with a given id.
-     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
-     * vertex within a graph or network.
+     * The constructor function initializes a vertex with an optional value.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is of type `VertexId`, which is
+     * typically a unique identifier for each vertex in a graph.
+     * @param {T} [val] - The "val" parameter is an optional parameter of type T. 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);
+    constructor(id: VertexId, val?: T);
 }
-export declare class UndirectedEdge extends AbstractEdge {
+export declare class UndirectedEdge<T = number> extends AbstractEdge<T> {
     /**
-     * The constructor function initializes an instance of a class with two vertex IDs and an optional weight.
+     * The constructor function initializes an instance of a class with two vertex IDs, an optional weight, and an optional
+     * value.
      * @param {VertexId} v1 - The parameter `v1` is of type `VertexId` and represents the first vertex in the edge.
      * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
-     * graph.
-     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
-     * between two vertices.
+     * graph edge.
+     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
+     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It represents the value associated with
+     * the edge.
      */
-    constructor(v1: VertexId, v2: VertexId, weight?: number);
+    constructor(v1: VertexId, v2: VertexId, weight?: number, val?: T);
     private _vertices;
     get vertices(): [VertexId, VertexId];
     set vertices(v: [VertexId, VertexId]);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getVertices(): [VertexId, VertexId];
 }
-export declare class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
-    constructor();
+export declare class UndirectedGraph<V extends UndirectedVertex<any>, E extends UndirectedEdge<any>> extends AbstractGraph<V, E> {
+    private readonly _vertexConstructor;
+    private readonly _edgeConstructor;
+    constructor(vertexConstructor: new (id: VertexId, val?: V['val']) => V, edgeConstructor: new (src: VertexId, dest: VertexId, weight?: number, val?: E['val']) => E);
     protected _edges: Map<V, E[]>;
     get edges(): Map<V, E[]>;
-    protected set edges(v: Map<V, E[]>);
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * 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 id
+     * @param val
+     */
+    _createVertex(id: VertexId, val?: V['val']): V;
+    /**
+     * 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 src
+     * @param dest
+     * @param weight
+     * @param val
      */
-    getEdges(): Map<V, E[]>;
+    _createEdge(src: VertexId, dest: VertexId, 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 either a vertex object (`V`) or a vertex ID
-     * (`VertexId`). It can also be `null`.
-     * @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).
-     * @returns an edge (E) or null.
+     * The function `getEdge` returns the first undirected edge that connects two given vertices, or null if no such edge
+     * exists.
+     * @param {V | null | VertexId} v1 - The parameter `v1` represents either an `V`
+     * object, `null`, or a `VertexId`. It is used to specify one of the vertices of the edge.
+     * @param {V | null | VertexId} v2 - The parameter `v2` represents either an `UndirectedVertex`
+     * object or a `VertexId` (identifier) of an undirected vertex.
+     * @returns an instance of `E` or `null`.
      */
     getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null;
     /**
-     * The function adds an edge to a graph by connecting two vertices.
-     * @param {E} edge - The `edge` parameter is an object of type `E`, which represents an edge in a graph.
+     * The function adds an undirected edge to a graph by updating the adjacency list.
+     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
+     * array of two vertices connected by the edge.
      * @returns a boolean value.
      */
     addEdge(edge: E): boolean;
     /**
-     * The function removes an edge between two vertices in a graph and returns the removed edge, or null if either of the
-     * vertices does not exist.
-     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
-     * @param {V | VertexId} v2 - V | VertexId: The second vertex or vertex ID of the edge to be removed.
-     * @returns the removed edge (E) if it exists, or null if either of the vertices (v1 or v2) does not exist.
+     * The function removes an edge between two vertices in an undirected graph.
+     * @param {V | VertexId} v1 - The parameter `v1` represents either an `V` object or
+     * a `VertexId`. It is used to specify one of the vertices of the edge that needs to be removed.
+     * @param {V | VertexId} v2 - The parameter `v2` represents either an instance of the
+     * `UndirectedVertex` class or a `VertexId`. It is used to identify the second vertex of the edge that needs to be
+     * removed.
+     * @returns The function `removeEdgeBetween` returns an `E` object if an edge is successfully removed
+     * between the two vertices `v1` and `v2`. If either `v1` or `v2` is not found in the graph, or if there is no edge
+     * between them, the function returns `null`.
      */
     removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): 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.
-     * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
+     * The removeEdge function removes an edge between two vertices in an undirected graph.
+     * @param edge - An object representing an undirected edge. It has a property called "vertices" which is an array
+     * containing the two vertices connected by the edge.
+     * @returns The method is returning an UndirectedEdge object or null.
      */
     removeEdge(edge: E): E | null;
     /**
-     * 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`.
-     * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
-     * edges that are incident to that vertex.
+     * The function "degreeOf" returns the degree of a given vertex in an undirected graph.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or an
+     * `V`.
+     * @returns the degree of the vertex.
      */
     degreeOf(vertexOrId: VertexId | V): number;
     /**
-     * The function "edgesOf" returns an array of edges connected to a given vertex.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
-     * @returns an array of edges connected to the specified vertex. If the vertex exists in the graph, the function
-     * returns the array of edges connected to that vertex. If the vertex does not exist in the graph, the function returns
-     * an empty array.
+     * The function "edgesOf" returns an array of undirected edges connected to a given vertex or vertex ID.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or an
+     * `V`.
+     * @returns an array of UndirectedEdge objects.
      */
     edgesOf(vertexOrId: VertexId | 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[]`.
+     * The function "edgeSet" returns an array of unique undirected edges from a set of edges.
+     * @returns The method `edgeSet()` returns an array of `E` objects.
      */
     edgeSet(): E[];
     /**
-     * The function "getEdgesOf" returns an array of edges connected to 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`).
-     * @returns an array of edges (E[]) that are connected to the specified vertex or vertex ID.
+     * The function "getEdgesOf" returns an array of undirected edges connected to a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either an
+     * `V` object or a `VertexId`.
+     * @returns The function `getEdgesOf` returns an array of `E` objects.
      */
     getEdgesOf(vertexOrId: V | VertexId): E[];
     /**
-     * The function "getNeighbors" returns an array of neighboring vertices of a given vertex.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
-     * @returns an array of vertices (V[]).
+     * The function `getNeighbors` returns an array of neighboring vertices of a given vertex in an undirected graph.
+     * @param {V | VertexId} vertexOrId - The `vertexOrId` parameter can be either an
+     * `V` object or a `VertexId`. It represents the vertex for which we want to find the neighbors.
+     * @returns an array of UndirectedVertex objects.
      */
     getNeighbors(vertexOrId: V | VertexId): V[];
     /**
-     * The function "getEndsOfEdge" returns the vertices at the ends of a given edge, or null if the edge does not exist in
-     * the graph.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
-     * graph and both vertices are found. If the edge does not exist or one or both vertices are not found, it returns
-     * `null`.
+     * The function "getEndsOfEdge" returns the two vertices that form the ends of a given undirected edge, or null if the
+     * edge does not exist in the graph.
+     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
+     * array containing two vertices that the edge connects.
+     * @returns The function `getEndsOfEdge` returns an array containing the two ends of the given `edge` if the edge
+     * exists in the graph. If the edge does not exist, it returns `null`.
      */
     getEndsOfEdge(edge: E): [V, V] | null;
+    protected _setEdges(v: Map<V, E[]>): void;
 }

package/dist/data-structures/graph/undirected-graph.js

@@ -64,12 +64,14 @@ var abstract_graph_1 = require("./abstract-graph");
 var UndirectedVertex = /** @class */ (function (_super) {
     __extends(UndirectedVertex, _super);
     /**
-     * The constructor function initializes an object with a given id.
-     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
-     * vertex within a graph or network.
+     * The constructor function initializes a vertex with an optional value.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is of type `VertexId`, which is
+     * typically a unique identifier for each vertex in a graph.
+     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to initialize the value of the
+     * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    function UndirectedVertex(id) {
-        return _super.call(this, id) || this;
+    function UndirectedVertex(id, val) {
+        return _super.call(this, id, val) || this;
     }
     return UndirectedVertex;
 }(abstract_graph_1.AbstractVertex));
@@ -77,15 +79,17 @@ exports.UndirectedVertex = UndirectedVertex;
 var UndirectedEdge = /** @class */ (function (_super) {
     __extends(UndirectedEdge, _super);
     /**
-     * The constructor function initializes an instance of a class with two vertex IDs and an optional weight.
+     * The constructor function initializes an instance of a class with two vertex IDs, an optional weight, and an optional
+     * value.
      * @param {VertexId} v1 - The parameter `v1` is of type `VertexId` and represents the first vertex in the edge.
      * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
-     * graph.
-     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
-     * between two vertices.
+     * graph edge.
+     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
+     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It represents the value associated with
+     * the edge.
      */
-    function UndirectedEdge(v1, v2, weight) {
-        var _this = _super.call(this, weight) || this;
+    function UndirectedEdge(v1, v2, weight, val) {
+        var _this = _super.call(this, weight, val) || this;
         _this._vertices = [v1, v2];
         return _this;
     }
@@ -99,19 +103,15 @@ var UndirectedEdge = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    UndirectedEdge.prototype.getVertices = function () {
-        return this._vertices;
-    };
     return UndirectedEdge;
 }(abstract_graph_1.AbstractEdge));
 exports.UndirectedEdge = UndirectedEdge;
 var UndirectedGraph = /** @class */ (function (_super) {
     __extends(UndirectedGraph, _super);
-    function UndirectedGraph() {
+    function UndirectedGraph(vertexConstructor, edgeConstructor) {
         var _this = _super.call(this) || this;
+        _this._vertexConstructor = vertexConstructor;
+        _this._edgeConstructor = edgeConstructor;
         _this._edges = new Map();
         return _this;
     }
@@ -119,32 +119,46 @@ var UndirectedGraph = /** @class */ (function (_super) {
         get: function () {
             return this._edges;
         },
-        set: function (v) {
-            this._edges = v;
-        },
         enumerable: false,
         configurable: true
     });
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * 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 id
+     * @param val
      */
-    UndirectedGraph.prototype.getEdges = function () {
-        return this._edges;
+    UndirectedGraph.prototype._createVertex = function (id, val) {
+        return new this._vertexConstructor(id, val);
     };
     /**
-     * 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 either a vertex object (`V`) or a vertex ID
-     * (`VertexId`). It can also be `null`.
-     * @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).
-     * @returns an edge (E) or null.
+     * 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 src
+     * @param dest
+     * @param weight
+     * @param val
+     */
+    UndirectedGraph.prototype._createEdge = function (src, dest, weight, val) {
+        if (weight === undefined || weight === null)
+            weight = 1;
+        return new this._edgeConstructor(src, dest, weight, val);
+    };
+    /**
+     * The function `getEdge` returns the first undirected edge that connects two given vertices, or null if no such edge
+     * exists.
+     * @param {V | null | VertexId} v1 - The parameter `v1` represents either an `V`
+     * object, `null`, or a `VertexId`. It is used to specify one of the vertices of the edge.
+     * @param {V | null | VertexId} v2 - The parameter `v2` represents either an `UndirectedVertex`
+     * object or a `VertexId` (identifier) of an undirected vertex.
+     * @returns an instance of `E` or `null`.
      */
     UndirectedGraph.prototype.getEdge = function (v1, v2) {
         var _a;
         var edges = [];
         if (v1 !== null && v2 !== null) {
-            var vertex1 = this.getVertex(v1);
-            var vertex2_1 = this.getVertex(v2);
+            var vertex1 = this._getVertex(v1);
+            var vertex2_1 = this._getVertex(v2);
             if (vertex1 && vertex2_1) {
                 edges = (_a = this._edges.get(vertex1)) === null || _a === void 0 ? void 0 : _a.filter(function (e) { return e.vertices.includes(vertex2_1.id); });
             }
@@ -152,8 +166,9 @@ var UndirectedGraph = /** @class */ (function (_super) {
         return edges ? edges[0] || null : null;
     };
     /**
-     * The function adds an edge to a graph by connecting two vertices.
-     * @param {E} edge - The `edge` parameter is an object of type `E`, which represents an edge in a graph.
+     * The function adds an undirected edge to a graph by updating the adjacency list.
+     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
+     * array of two vertices connected by the edge.
      * @returns a boolean value.
      */
     UndirectedGraph.prototype.addEdge = function (edge) {
@@ -161,7 +176,7 @@ var UndirectedGraph = /** @class */ (function (_super) {
         try {
             for (var _b = __values(edge.vertices), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var end = _c.value;
-                var endVertex = this.getVertex(end);
+                var endVertex = this._getVertex(end);
                 if (endVertex === null)
                     return false;
                 if (endVertex) {
@@ -185,15 +200,19 @@ var UndirectedGraph = /** @class */ (function (_super) {
         return true;
     };
     /**
-     * The function removes an edge between two vertices in a graph and returns the removed edge, or null if either of the
-     * vertices does not exist.
-     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
-     * @param {V | VertexId} v2 - V | VertexId: The second vertex or vertex ID of the edge to be removed.
-     * @returns the removed edge (E) if it exists, or null if either of the vertices (v1 or v2) does not exist.
+     * The function removes an edge between two vertices in an undirected graph.
+     * @param {V | VertexId} v1 - The parameter `v1` represents either an `V` object or
+     * a `VertexId`. It is used to specify one of the vertices of the edge that needs to be removed.
+     * @param {V | VertexId} v2 - The parameter `v2` represents either an instance of the
+     * `UndirectedVertex` class or a `VertexId`. It is used to identify the second vertex of the edge that needs to be
+     * removed.
+     * @returns The function `removeEdgeBetween` returns an `E` object if an edge is successfully removed
+     * between the two vertices `v1` and `v2`. If either `v1` or `v2` is not found in the graph, or if there is no edge
+     * between them, the function returns `null`.
      */
     UndirectedGraph.prototype.removeEdgeBetween = function (v1, v2) {
-        var vertex1 = this.getVertex(v1);
-        var vertex2 = this.getVertex(v2);
+        var vertex1 = this._getVertex(v1);
+        var vertex2 = this._getVertex(v2);
         if (!vertex1 || !vertex2) {
             return null;
         }
@@ -209,23 +228,23 @@ var UndirectedGraph = /** @class */ (function (_super) {
         return removed;
     };
     /**
-     * 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.
-     * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
+     * The removeEdge function removes an edge between two vertices in an undirected graph.
+     * @param edge - An object representing an undirected edge. It has a property called "vertices" which is an array
+     * containing the two vertices connected by the edge.
+     * @returns The method is returning an UndirectedEdge object or null.
      */
     UndirectedGraph.prototype.removeEdge = function (edge) {
         return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
     };
     /**
-     * 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`.
-     * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
-     * edges that are incident to that vertex.
+     * The function "degreeOf" returns the degree of a given vertex in an undirected graph.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or an
+     * `V`.
+     * @returns the degree of the vertex.
      */
     UndirectedGraph.prototype.degreeOf = function (vertexOrId) {
         var _a;
-        var vertex = this.getVertex(vertexOrId);
+        var vertex = this._getVertex(vertexOrId);
         if (vertex) {
             return ((_a = this._edges.get(vertex)) === null || _a === void 0 ? void 0 : _a.length) || 0;
         }
@@ -234,14 +253,13 @@ var UndirectedGraph = /** @class */ (function (_super) {
         }
     };
     /**
-     * The function "edgesOf" returns an array of edges connected to a given vertex.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
-     * @returns an array of edges connected to the specified vertex. If the vertex exists in the graph, the function
-     * returns the array of edges connected to that vertex. If the vertex does not exist in the graph, the function returns
-     * an empty array.
+     * The function "edgesOf" returns an array of undirected edges connected to a given vertex or vertex ID.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or an
+     * `V`.
+     * @returns an array of UndirectedEdge objects.
      */
     UndirectedGraph.prototype.edgesOf = function (vertexOrId) {
-        var vertex = this.getVertex(vertexOrId);
+        var vertex = this._getVertex(vertexOrId);
         if (vertex) {
             return this._edges.get(vertex) || [];
         }
@@ -250,8 +268,8 @@ var UndirectedGraph = /** @class */ (function (_super) {
         }
     };
     /**
-     * The function "edgeSet" returns an array of unique edges from a set of edges.
-     * @returns The method `edgeSet()` returns an array of type `E[]`.
+     * The function "edgeSet" returns an array of unique undirected edges from a set of edges.
+     * @returns The method `edgeSet()` returns an array of `E` objects.
      */
     UndirectedGraph.prototype.edgeSet = function () {
         var edgeSet = new Set();
@@ -263,34 +281,34 @@ var UndirectedGraph = /** @class */ (function (_super) {
         return __spreadArray([], __read(edgeSet), false);
     };
     /**
-     * The function "getEdgesOf" returns an array of edges connected to 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`).
-     * @returns an array of edges (E[]) that are connected to the specified vertex or vertex ID.
+     * The function "getEdgesOf" returns an array of undirected edges connected to a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either an
+     * `V` object or a `VertexId`.
+     * @returns The function `getEdgesOf` returns an array of `E` objects.
      */
     UndirectedGraph.prototype.getEdgesOf = function (vertexOrId) {
-        var vertex = this.getVertex(vertexOrId);
+        var vertex = this._getVertex(vertexOrId);
         if (!vertex) {
             return [];
         }
         return this._edges.get(vertex) || [];
     };
     /**
-     * The function "getNeighbors" returns an array of neighboring vertices of a given vertex.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
-     * @returns an array of vertices (V[]).
+     * The function `getNeighbors` returns an array of neighboring vertices of a given vertex in an undirected graph.
+     * @param {V | VertexId} vertexOrId - The `vertexOrId` parameter can be either an
+     * `V` object or a `VertexId`. It represents the vertex for which we want to find the neighbors.
+     * @returns an array of UndirectedVertex objects.
      */
     UndirectedGraph.prototype.getNeighbors = function (vertexOrId) {
         var e_2, _a;
         var neighbors = [];
-        var vertex = this.getVertex(vertexOrId);
+        var vertex = this._getVertex(vertexOrId);
         if (vertex) {
             var neighborEdges = this.getEdgesOf(vertex);
             try {
                 for (var neighborEdges_1 = __values(neighborEdges), neighborEdges_1_1 = neighborEdges_1.next(); !neighborEdges_1_1.done; neighborEdges_1_1 = neighborEdges_1.next()) {
                     var edge = neighborEdges_1_1.value;
-                    var neighbor = this.getVertex(edge.vertices.filter(function (e) { return e !== vertex.id; })[0]);
+                    var neighbor = this._getVertex(edge.vertices.filter(function (e) { return e !== vertex.id; })[0]);
                     if (neighbor) {
                         neighbors.push(neighbor);
                     }
@@ -307,19 +325,19 @@ var UndirectedGraph = /** @class */ (function (_super) {
         return neighbors;
     };
     /**
-     * The function "getEndsOfEdge" returns the vertices at the ends of a given edge, or null if the edge does not exist in
-     * the graph.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
-     * graph and both vertices are found. If the edge does not exist or one or both vertices are not found, it returns
-     * `null`.
+     * The function "getEndsOfEdge" returns the two vertices that form the ends of a given undirected edge, or null if the
+     * edge does not exist in the graph.
+     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
+     * array containing two vertices that the edge connects.
+     * @returns The function `getEndsOfEdge` returns an array containing the two ends of the given `edge` if the edge
+     * exists in the graph. If the edge does not exist, it returns `null`.
      */
     UndirectedGraph.prototype.getEndsOfEdge = function (edge) {
         if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
             return null;
         }
-        var v1 = this.getVertex(edge.vertices[0]);
-        var v2 = this.getVertex(edge.vertices[1]);
+        var v1 = this._getVertex(edge.vertices[0]);
+        var v2 = this._getVertex(edge.vertices[1]);
         if (v1 && v2) {
             return [v1, v2];
         }
@@ -327,6 +345,9 @@ var UndirectedGraph = /** @class */ (function (_super) {
             return null;
         }
     };
+    UndirectedGraph.prototype._setEdges = function (v) {
+        this._edges = v;
+    };
     return UndirectedGraph;
 }(abstract_graph_1.AbstractGraph));
 exports.UndirectedGraph = UndirectedGraph;

package/dist/data-structures/hash/coordinate-map.d.ts

@@ -9,11 +9,6 @@ export declare class CoordinateMap<V> extends Map<any, V> {
     constructor(joint?: string);
     protected _joint: string;
     get joint(): string;
-    protected set joint(v: string);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getJoint(): string;
     /**
      * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
      * key array with a specified delimiter.
@@ -46,4 +41,5 @@ export declare class CoordinateMap<V> extends Map<any, V> {
      * `key` array joined together using the `_joint` property.
      */
     delete(key: number[]): boolean;
+    protected _setJoint(v: string): void;
 }

package/dist/data-structures/hash/coordinate-map.js

@@ -36,18 +36,9 @@ var CoordinateMap = /** @class */ (function (_super) {
         get: function () {
             return this._joint;
         },
-        set: function (v) {
-            this._joint = v;
-        },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    CoordinateMap.prototype.getJoint = function () {
-        return this._joint;
-    };
     /**
      * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
      * key array with a specified delimiter.
@@ -88,6 +79,9 @@ var CoordinateMap = /** @class */ (function (_super) {
     CoordinateMap.prototype.delete = function (key) {
         return _super.prototype.delete.call(this, key.join(this._joint));
     };
+    CoordinateMap.prototype._setJoint = function (v) {
+        this._joint = v;
+    };
     return CoordinateMap;
 }(Map));
 exports.CoordinateMap = CoordinateMap;

package/dist/data-structures/hash/coordinate-set.d.ts

@@ -5,15 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export declare class CoordinateSet extends Set {
+export declare class CoordinateSet extends Set<any> {
     constructor(joint?: string);
     protected _joint: string;
     get joint(): string;
-    protected set joint(v: string);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getJoint(): string;
     /**
      * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
      * joining its elements with a specified separator.
@@ -38,4 +33,5 @@ export declare class CoordinateSet extends Set {
      * `value` array joined together using the `_joint` property.
      */
     delete(value: number[]): boolean;
+    protected _setJoint(v: string): void;
 }

package/dist/data-structures/hash/coordinate-set.js

@@ -36,18 +36,9 @@ var CoordinateSet = /** @class */ (function (_super) {
         get: function () {
             return this._joint;
         },
-        set: function (v) {
-            this._joint = v;
-        },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    CoordinateSet.prototype.getJoint = function () {
-        return this._joint;
-    };
     /**
      * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
      * joining its elements with a specified separator.
@@ -78,6 +69,9 @@ var CoordinateSet = /** @class */ (function (_super) {
     CoordinateSet.prototype.delete = function (value) {
         return _super.prototype.delete.call(this, value.join(this._joint));
     };
+    CoordinateSet.prototype._setJoint = function (v) {
+        this._joint = v;
+    };
     return CoordinateSet;
 }(Set));
 exports.CoordinateSet = CoordinateSet;