data-structure-typed 0.9.16 → 1.3.0

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

@@ -1,3 +1,4 @@
 export * from './abstract-graph';
 export * from './directed-graph';
 export * from './undirected-graph';
+export * from './map-graph';

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./abstract-graph"), exports);
 __exportStar(require("./directed-graph"), exports);
 __exportStar(require("./undirected-graph"), exports);
+__exportStar(require("./map-graph"), exports);

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

@@ -0,0 +1,79 @@
+import { MapGraphCoordinate, VertexId } from '../../types';
+import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
+export declare class MapVertex<T = any> extends DirectedVertex<T> {
+    /**
+     * 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.
+     * @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 {T} [val] - The "val" parameter is an optional value of type T. It is not required to be provided when
+     * creating an instance of the class.
+     */
+    constructor(id: VertexId, lat: number, long: number, val?: T);
+    private _lat;
+    get lat(): number;
+    set lat(value: number);
+    private _long;
+    get long(): number;
+    set long(value: number);
+}
+export declare class MapEdge<T = any> extends DirectedEdge<T> {
+    /**
+     * 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
+     * a graph.
+     * @param {VertexId} 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 {T} [val] - The "val" parameter is an optional parameter of type T. It is used to store additional
+     * information or data associated with the edge.
+     */
+    constructor(src: VertexId, dest: VertexId, weight?: number, val?: T);
+}
+export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEdge = MapEdge> extends DirectedGraph<V, E> {
+    /**
+     * 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);
+    private _origin;
+    get origin(): MapGraphCoordinate;
+    set origin(value: MapGraphCoordinate);
+    private _bottomRight;
+    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
+     * 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`.
+     * @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 `V`.
+     */
+    createVertex(id: VertexId, 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
+     * 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 [val] - The `val` 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, casted as type `E`.
+     */
+    createEdge(src: VertexId, dest: VertexId, weight?: number, val?: E['val']): E;
+}

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

@@ -0,0 +1,111 @@
+"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 id, latitude, longitude, and an optional value.
+     * @param {VertexId} id - The `id` parameter is of type `VertexId` 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 {T} [val] - The "val" parameter is an optional value of type T. It is not required to be provided when
+     * creating an instance of the class.
+     */
+    constructor(id, lat, long, val) {
+        super(id, val);
+        this._lat = lat;
+        this._long = long;
+    }
+    get lat() {
+        return this._lat;
+    }
+    set lat(value) {
+        this._lat = value;
+    }
+    get long() {
+        return this._long;
+    }
+    set long(value) {
+        this._long = value;
+    }
+}
+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 {VertexId} 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 {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 is used to store additional
+     * information or data associated with the edge.
+     */
+    constructor(src, dest, weight, val) {
+        super(src, dest, weight, val);
+    }
+}
+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;
+    }
+    set origin(value) {
+        this._origin = value;
+    }
+    get bottomRight() {
+        return this._bottomRight;
+    }
+    set bottomRight(value) {
+        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
+     * 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`.
+     * @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 `V`.
+     */
+    createVertex(id, val, lat = this.origin[0], long = this.origin[1]) {
+        return new MapVertex(id, 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
+     * 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 [val] - The `val` 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, casted as type `E`.
+     */
+    createEdge(src, dest, weight, val) {
+        return new MapEdge(src, dest, weight, val);
+    }
+}
+exports.MapGraph = MapGraph;

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

@@ -1,25 +1,127 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
-import type { VertexId } from '../types';
-export declare class UndirectedVertex extends AbstractVertex {
-    constructor(id: VertexId);
+import type { VertexId } from '../../types';
+import { IUNDirectedGraph } from '../../interfaces';
+export declare class UndirectedVertex<T = number> extends AbstractVertex<T> {
+    /**
+     * 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
+     * used to uniquely identify the vertex within a graph or network.
+     * @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, val?: T);
 }
-export declare class UndirectedEdge extends AbstractEdge {
-    constructor(v1: VertexId, v2: VertexId, weight?: number);
+export declare class UndirectedEdge<T = number> extends AbstractEdge<T> {
+    /**
+     * 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
+     * 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 is used to store a value associated
+     * with the edge.
+     */
+    constructor(v1: VertexId, v2: VertexId, weight?: number, val?: T);
     private _vertices;
     get vertices(): [VertexId, VertexId];
     set vertices(v: [VertexId, VertexId]);
 }
-export declare class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
-    protected _edges: Map<V, E[]>;
+export declare class UndirectedGraph<V extends UndirectedVertex<any> = UndirectedVertex, E extends UndirectedEdge<any> = UndirectedEdge> extends AbstractGraph<V, E> implements IUNDirectedGraph<V, E> {
+    /**
+     * The constructor initializes a new Map object to store edges.
+     */
     constructor();
+    protected _edges: Map<V, E[]>;
+    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
+     * 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
+     * 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;
+    /**
+     * 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 {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;
+    /**
+     * 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).
+     * @returns an edge (E) or null.
+     */
     getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null;
-    addEdge(edge: E): boolean;
+    /**
+     * 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.
+     * @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;
+    /**
+     * 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.
+     */
     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 connected to that vertex.
+     */
     degreeOf(vertexOrId: VertexId | 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
+     * 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[];
+    /**
+     * The function "edgeSet" returns an array of unique edges from a set of edges.
+     * @returns The method `edgeSet()` returns an array of type `E[]`.
+     */
     edgeSet(): E[];
-    getEdgesOf(vertexOrId: V | VertexId): 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`).
+     * @returns an array of vertices (V[]).
+     */
     getNeighbors(vertexOrId: V | VertexId): V[];
+    /**
+     * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
+     * it returns null.
+     * @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. If the edge does not exist, it returns `null`.
+     */
     getEndsOfEdge(edge: E): [V, V] | null;
+    /**
+     * The function adds an edge to the graph by updating the adjacency list with the vertices of the edge.
+     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @returns a boolean value.
+     */
+    protected _addEdgeOnly(edge: E): boolean;
+    /**
+     * The function sets the edges of a graph.
+     * @param v - A map where the keys are of type V and the values are arrays of type E.
+     */
+    protected _setEdges(v: Map<V, E[]>): void;
 }