min-heap-typed 1.40.0-rc → 1.41.0

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

@@ -0,0 +1,73 @@
+import { MapGraphCoordinate, VertexKey } from '../../types';
+import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
+export declare class MapVertex<V = any> extends DirectedVertex<V> {
+    lat: number;
+    long: number;
+    /**
+     * The constructor function initializes an object with an key, latitude, longitude, and an optional value.
+     * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex.
+     * @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.
+     * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
+     * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
+     * values ranging from -180 to 180.
+     * @param {V} [value] - The "value" parameter is an optional value of type V. It is not required to be provided when
+     * creating an instance of the class.
+     */
+    constructor(key: VertexKey, value: V, lat: number, long: number);
+}
+export declare class MapEdge<E = any> extends DirectedEdge<E> {
+    /**
+     * The constructor function initializes a new instance of a class with the given source, destination, weight, and
+     * value.
+     * @param {VertexKey} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * a graph.
+     * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
+     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
+     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store additional
+     * information or data associated with the edge.
+     */
+    constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E);
+}
+export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVertex<V>, EO extends MapEdge<E> = MapEdge<E>> extends DirectedGraph<V, E, VO, EO> {
+    /**
+     * The constructor function initializes the origin and bottomRight properties of a MapGraphCoordinate object.
+     * @param {MapGraphCoordinate} origin - The `origin` parameter is a `MapGraphCoordinate` object that represents the
+     * starting point or reference point of the map graph. It defines the coordinates of the top-left corner of the map
+     * graph.
+     * @param {MapGraphCoordinate} [bottomRight] - The `bottomRight` parameter is an optional parameter of type
+     * `MapGraphCoordinate`. It represents the bottom right coordinate of a map graph. If this parameter is not provided,
+     * it will default to `undefined`.
+     */
+    constructor(origin: MapGraphCoordinate, bottomRight?: MapGraphCoordinate);
+    protected _origin: MapGraphCoordinate;
+    get origin(): MapGraphCoordinate;
+    protected _bottomRight: MapGraphCoordinate | undefined;
+    get bottomRight(): MapGraphCoordinate | undefined;
+    /**
+     * 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 [value] - The `value` parameter is an optional value that can be assigned to the `value` property of the vertex. It
+     * is of type `V`, which means it should be of the same type as the `value` property of the vertex class `VO`.
+     * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
+     * position of the vertex on the Earth's surface in the north-south direction.
+     * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
+     * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
+     */
+    createVertex(key: VertexKey, value?: V, lat?: number, long?: number): VO;
+    /**
+     * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
+     * @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.
+     * If the weight is not provided, it can be set to a default value or left undefined.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type,
+     * depending on the specific implementation of the `MapEdge` class.
+     * @returns a new instance of the `MapEdge` class, cast as type `EO`.
+     */
+    createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO;
+}

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapGraph = exports.MapEdge = exports.MapVertex = void 0;
+const directed_graph_1 = require("./directed-graph");
+class MapVertex extends directed_graph_1.DirectedVertex {
+    /**
+     * 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.
+     * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
+     * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
+     * values ranging from -180 to 180.
+     * @param {V} [value] - The "value" parameter is an optional value of type V. It is not required to be provided when
+     * creating an instance of the class.
+     */
+    constructor(key, value, lat, long) {
+        super(key, value);
+        this.lat = lat;
+        this.long = long;
+    }
+}
+exports.MapVertex = MapVertex;
+class MapEdge extends directed_graph_1.DirectedEdge {
+    /**
+     * The constructor function initializes a new instance of a class with the given source, destination, weight, and
+     * value.
+     * @param {VertexKey} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * a graph.
+     * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
+     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
+     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store additional
+     * information or data associated with the edge.
+     */
+    constructor(src, dest, weight, value) {
+        super(src, dest, weight, value);
+    }
+}
+exports.MapEdge = MapEdge;
+class MapGraph extends directed_graph_1.DirectedGraph {
+    /**
+     * The constructor function initializes the origin and bottomRight properties of a MapGraphCoordinate object.
+     * @param {MapGraphCoordinate} origin - The `origin` parameter is a `MapGraphCoordinate` object that represents the
+     * starting point or reference point of the map graph. It defines the coordinates of the top-left corner of the map
+     * graph.
+     * @param {MapGraphCoordinate} [bottomRight] - The `bottomRight` parameter is an optional parameter of type
+     * `MapGraphCoordinate`. It represents the bottom right coordinate of a map graph. If this parameter is not provided,
+     * it will default to `undefined`.
+     */
+    constructor(origin, bottomRight) {
+        super();
+        this._origin = [0, 0];
+        this._origin = origin;
+        this._bottomRight = bottomRight;
+    }
+    get origin() {
+        return this._origin;
+    }
+    get bottomRight() {
+        return this._bottomRight;
+    }
+    /**
+     * 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 [value] - The `value` parameter is an optional value that can be assigned to the `value` property of the vertex. It
+     * is of type `V`, which means it should be of the same type as the `value` property of the vertex class `VO`.
+     * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
+     * position of the vertex on the Earth's surface in the north-south direction.
+     * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
+     * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
+     */
+    createVertex(key, value, lat = this.origin[0], long = this.origin[1]) {
+        return new MapVertex(key, value, lat, long);
+    }
+    /**
+     * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
+     * @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.
+     * If the weight is not provided, it can be set to a default value or left undefined.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type,
+     * depending on the specific implementation of the `MapEdge` class.
+     * @returns a new instance of the `MapEdge` class, cast as type `EO`.
+     */
+    createEdge(src, dest, weight, value) {
+        return new MapEdge(src, dest, weight, value);
+    }
+}
+exports.MapGraph = MapGraph;

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

@@ -0,0 +1,120 @@
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+import type { VertexKey } from '../../types';
+import { IGraph } from '../../interfaces';
+export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
+    /**
+     * The constructor function initializes a vertex with an optional value.
+     * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
+     * used to uniquely identify the vertex within a graph or network.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
+     * vertex. If no value is provided, the vertex will be initialized with a default value.
+     */
+    constructor(key: VertexKey, value?: V);
+}
+export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
+    vertices: [VertexKey, VertexKey];
+    /**
+     * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
+     * value.
+     * @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 {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store a value associated
+     * with the edge.
+     */
+    constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E);
+}
+export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVertex<V> = UndirectedVertex<V>, EO extends UndirectedEdge<E> = UndirectedEdge<E>> extends AbstractGraph<V, E, VO, EO> implements IGraph<V, E, VO, EO> {
+    /**
+     * The constructor initializes a new Map object to store edges.
+     */
+    constructor();
+    protected _edges: Map<VO, EO[]>;
+    get edges(): Map<VO, EO[]>;
+    /**
+     * The function creates a new vertex with an optional value and returns it.
+     * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
+     * vertex from another in the graph.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the vertex. If a value is provided,
+     * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
+     * the vertex.
+     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `VO`.
+     */
+    createVertex(key: VertexKey, value?: VO['value']): VO;
+    /**
+     * The function creates an undirected edge between two vertices 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
+     * no weight is provided, it defaults to 1.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * is used to store additional information or data associated with the edge.
+     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `EO`.
+     */
+    createEdge(v1: VertexKey, v2: VertexKey, weight?: number, value?: EO['value']): EO;
+    /**
+     * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
+     * @param {VO | VertexKey | null} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
+     * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
+     * @param {VO | VertexKey | null} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
+     * object), `null`, or `VertexKey` (vertex ID).
+     * @returns an edge (EO) or null.
+     */
+    getEdge(v1: VO | VertexKey | null, v2: VO | VertexKey | null): EO | null;
+    /**
+     * The function removes an edge between two vertices 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 null if either of the vertices (VO) does not exist.
+     */
+    deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | null;
+    /**
+     * The deleteEdge function removes an edge between two vertices in a graph.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The method is returning either the removed edge (of type EO) or null if the edge was not found.
+     */
+    deleteEdge(edge: EO): EO | null;
+    /**
+     * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges 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.
+     */
+    degreeOf(vertexOrKey: VertexKey | VO): number;
+    /**
+     * The function returns the edges 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.
+     */
+    edgesOf(vertexOrKey: VertexKey | VO): EO[];
+    /**
+     * The function "edgeSet" returns an array of unique edges from a set of edges.
+     * @returns The method `edgeSet()` returns an array of type `EO[]`.
+     */
+    edgeSet(): EO[];
+    /**
+     * The function "getNeighbors" returns an array of neighboring vertices 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[]).
+     */
+    getNeighbors(vertexOrKey: VO | VertexKey): VO[];
+    /**
+     * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
+     * it returns null.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
+     * graph. If the edge does not exist, it returns `null`.
+     */
+    getEndsOfEdge(edge: EO): [VO, VO] | null;
+    /**
+     * The function adds an edge to the graph by updating the adjacency list with the vertices 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;
+}

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

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndirectedGraph = exports.UndirectedEdge = exports.UndirectedVertex = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+const utils_1 = require("../../utils");
+const abstract_graph_1 = require("./abstract-graph");
+class UndirectedVertex extends abstract_graph_1.AbstractVertex {
+    /**
+     * The constructor function initializes a vertex with an optional value.
+     * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
+     * used to uniquely identify the vertex within a graph or network.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
+     * vertex. If no value is provided, the vertex will be initialized with a default value.
+     */
+    constructor(key, value) {
+        super(key, value);
+    }
+}
+exports.UndirectedVertex = UndirectedVertex;
+class UndirectedEdge extends abstract_graph_1.AbstractEdge {
+    /**
+     * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
+     * value.
+     * @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 {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store a value associated
+     * with the edge.
+     */
+    constructor(v1, v2, weight, value) {
+        super(weight, value);
+        this.vertices = [v1, v2];
+    }
+}
+exports.UndirectedEdge = UndirectedEdge;
+class UndirectedGraph extends abstract_graph_1.AbstractGraph {
+    /**
+     * The constructor initializes a new Map object to store edges.
+     */
+    constructor() {
+        super();
+        this._edges = new Map();
+    }
+    get edges() {
+        return this._edges;
+    }
+    /**
+     * The function creates a new vertex with an optional value and returns it.
+     * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
+     * vertex from another in the graph.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the vertex. If a value is provided,
+     * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
+     * the vertex.
+     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `VO`.
+     */
+    createVertex(key, value) {
+        return new UndirectedVertex(key, value !== null && value !== void 0 ? value : key);
+    }
+    /**
+     * The function creates an undirected edge between two vertices 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
+     * no weight is provided, it defaults to 1.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * is used to store additional information or data associated with the edge.
+     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `EO`.
+     */
+    createEdge(v1, v2, weight, value) {
+        return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, value);
+    }
+    /**
+     * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
+     * @param {VO | VertexKey | null} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
+     * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
+     * @param {VO | VertexKey | null} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
+     * object), `null`, or `VertexKey` (vertex ID).
+     * @returns an edge (EO) or null.
+     */
+    getEdge(v1, v2) {
+        var _a;
+        let edges = [];
+        if (v1 !== null && v2 !== null) {
+            const vertex1 = this._getVertex(v1);
+            const vertex2 = this._getVertex(v2);
+            if (vertex1 && vertex2) {
+                edges = (_a = this._edges.get(vertex1)) === null || _a === void 0 ? void 0 : _a.filter(e => e.vertices.includes(vertex2.key));
+            }
+        }
+        return edges ? edges[0] || null : null;
+    }
+    /**
+     * The function removes an edge between two vertices 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 null if either of the vertices (VO) does not exist.
+     */
+    deleteEdgeBetween(v1, v2) {
+        const vertex1 = this._getVertex(v1);
+        const vertex2 = this._getVertex(v2);
+        if (!vertex1 || !vertex2) {
+            return null;
+        }
+        const v1Edges = this._edges.get(vertex1);
+        let removed = null;
+        if (v1Edges) {
+            removed = (0, utils_1.arrayRemove)(v1Edges, (e) => e.vertices.includes(vertex2.key))[0] || null;
+        }
+        const v2Edges = this._edges.get(vertex2);
+        if (v2Edges) {
+            (0, utils_1.arrayRemove)(v2Edges, (e) => e.vertices.includes(vertex1.key));
+        }
+        return removed;
+    }
+    /**
+     * The deleteEdge function removes an edge between two vertices in a graph.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The method is returning either the removed edge (of type EO) or null if the edge was not found.
+     */
+    deleteEdge(edge) {
+        return this.deleteEdgeBetween(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 {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.
+     */
+    degreeOf(vertexOrKey) {
+        var _a;
+        const vertex = this._getVertex(vertexOrKey);
+        if (vertex) {
+            return ((_a = this._edges.get(vertex)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * The function returns the edges 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.
+     */
+    edgesOf(vertexOrKey) {
+        const vertex = this._getVertex(vertexOrKey);
+        if (vertex) {
+            return this._edges.get(vertex) || [];
+        }
+        else {
+            return [];
+        }
+    }
+    /**
+     * The function "edgeSet" returns an array of unique edges from a set of edges.
+     * @returns The method `edgeSet()` returns an array of type `EO[]`.
+     */
+    edgeSet() {
+        const edgeSet = new Set();
+        this._edges.forEach(edges => {
+            edges.forEach(edge => {
+                edgeSet.add(edge);
+            });
+        });
+        return [...edgeSet];
+    }
+    /**
+     * The function "getNeighbors" returns an array of neighboring vertices 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[]).
+     */
+    getNeighbors(vertexOrKey) {
+        const neighbors = [];
+        const vertex = this._getVertex(vertexOrKey);
+        if (vertex) {
+            const neighborEdges = this.edgesOf(vertex);
+            for (const edge of neighborEdges) {
+                const neighbor = this._getVertex(edge.vertices.filter(e => e !== vertex.key)[0]);
+                if (neighbor) {
+                    neighbors.push(neighbor);
+                }
+            }
+        }
+        return neighbors;
+    }
+    /**
+     * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
+     * it returns null.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
+     * graph. If the edge does not exist, it returns `null`.
+     */
+    getEndsOfEdge(edge) {
+        if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
+            return null;
+        }
+        const v1 = this._getVertex(edge.vertices[0]);
+        const v2 = this._getVertex(edge.vertices[1]);
+        if (v1 && v2) {
+            return [v1, v2];
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * The function adds an edge to the graph by updating the adjacency list with the vertices of the edge.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns a boolean value.
+     */
+    _addEdgeOnly(edge) {
+        for (const end of edge.vertices) {
+            const endVertex = this._getVertex(end);
+            if (endVertex === null)
+                return false;
+            if (endVertex) {
+                const edges = this._edges.get(endVertex);
+                if (edges) {
+                    edges.push(edge);
+                }
+                else {
+                    this._edges.set(endVertex, [edge]);
+                }
+            }
+        }
+        return true;
+    }
+}
+exports.UndirectedGraph = UndirectedGraph;

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

@@ -0,0 +1,44 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export declare class CoordinateMap<V> extends Map<any, V> {
+    constructor(joint?: string);
+    protected _joint: string;
+    get joint(): 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.
+     * @param {number[]} key - The parameter "key" is an array of numbers.
+     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
+     * (`super.has`) with the `key` array joined together using the `_joint` property.
+     */
+    has(key: number[]): boolean;
+    /**
+     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
+     * delimiter before calling the original set method.
+     * @param {number[]} key - The key parameter is an array of numbers.
+     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
+     * @returns The `set` method is returning the result of calling the `set` method of the superclass
+     * (`super.set(key.join(this._joint), value)`).
+     */
+    set(key: number[], value: V): this;
+    /**
+     * The function overrides the get method to join the key array with a specified joint and then calls the super get
+     * method.
+     * @param {number[]} key - An array of numbers
+     * @returns The code is returning the value associated with the specified key in the map.
+     */
+    get(key: number[]): V | undefined;
+    /**
+     * The function overrides the delete method and joins the key array using a specified joint character before calling
+     * the super delete method.
+     * @param {number[]} key - An array of numbers that represents the key to be deleted.
+     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
+     * `key` array joined together using the `_joint` property.
+     */
+    delete(key: number[]): boolean;
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoordinateMap = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+class CoordinateMap extends Map {
+    constructor(joint) {
+        super();
+        this._joint = '_';
+        if (joint !== undefined)
+            this._joint = joint;
+    }
+    get joint() {
+        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.
+     * @param {number[]} key - The parameter "key" is an array of numbers.
+     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
+     * (`super.has`) with the `key` array joined together using the `_joint` property.
+     */
+    has(key) {
+        return super.has(key.join(this._joint));
+    }
+    /**
+     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
+     * delimiter before calling the original set method.
+     * @param {number[]} key - The key parameter is an array of numbers.
+     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
+     * @returns The `set` method is returning the result of calling the `set` method of the superclass
+     * (`super.set(key.join(this._joint), value)`).
+     */
+    set(key, value) {
+        return super.set(key.join(this._joint), value);
+    }
+    /**
+     * The function overrides the get method to join the key array with a specified joint and then calls the super get
+     * method.
+     * @param {number[]} key - An array of numbers
+     * @returns The code is returning the value associated with the specified key in the map.
+     */
+    get(key) {
+        return super.get(key.join(this._joint));
+    }
+    /**
+     * The function overrides the delete method and joins the key array using a specified joint character before calling
+     * the super delete method.
+     * @param {number[]} key - An array of numbers that represents the key to be deleted.
+     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
+     * `key` array joined together using the `_joint` property.
+     */
+    delete(key) {
+        return super.delete(key.join(this._joint));
+    }
+}
+exports.CoordinateMap = CoordinateMap;