data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,4 +1,5 @@
-import { AbstractEdge, AbstractGraph, AbstractVertex, VertexId } from './abstract-graph';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+import type { IDirectedGraph, VertexId } from '../types';
 export declare class DirectedVertex extends AbstractVertex {
     constructor(id: VertexId);
 }
@@ -11,41 +12,142 @@ export declare class DirectedEdge extends AbstractEdge {
     get dest(): VertexId;
     set dest(v: VertexId);
 }
-export interface I_DirectedGraph<V, E> {
-    incomingEdgesOf(vertex: V): E[];
-    outgoingEdgesOf(vertex: V): E[];
-    inDegreeOf(vertexOrId: V | VertexId): number;
-    outDegreeOf(vertexOrId: V | VertexId): number;
-    getEdgeSrc(e: E): V | null;
-    getEdgeDest(e: E): V | null;
-}
-export type TopologicalStatus = 0 | 1 | 2;
-export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements I_DirectedGraph<V, E> {
+export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
     protected _outEdgeMap: Map<V, E[]>;
     protected _inEdgeMap: Map<V, E[]>;
     constructor();
+    /**
+     * The function `getEdge` returns the first edge between two vertices, given their source and destination.
+     * @param {V | null | VertexId} srcOrId - The `srcOrId` parameter can be either a vertex object (`V`), a vertex ID
+     * (`VertexId`), or `null`. It represents the source vertex of the edge.
+     * @param {V | null | VertexId} destOrId - The `destOrId` parameter is either a vertex object (`V`), a vertex ID
+     * (`VertexId`), or `null`. It represents the destination vertex of the edge.
+     * @returns an edge (E) or null.
+     */
     getEdge(srcOrId: V | null | VertexId, destOrId: V | null | VertexId): E | null;
+    /**
+     * The `addEdge` function adds an edge to a graph if the source and destination vertices exist.
+     * @param {E} edge - The parameter `edge` is of type `E`, which represents an edge in the graph. It contains
+     * information about the source vertex (`src`) and the destination vertex (`dest`) of the edge.
+     * @returns The `addEdge` function returns a boolean value. It returns `true` if the edge was successfully added to the
+     * graph, and `false` if either the source or destination vertices of the edge are not present in the graph.
+     */
     addEdge(edge: E): boolean;
+    /**
+     * The function removes an edge between two vertices in a directed graph and returns the removed edge.
+     * @param {V | VertexId} srcOrId - The source vertex or its ID.
+     * @param {V | VertexId} destOrId - The `destOrId` parameter in the `removeEdgeBetween` function represents the
+     * destination vertex of the edge that needs to be removed. It can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The function `removeEdgeBetween` returns the removed edge (`E`) if the edge between the source and
+     * destination vertices is successfully removed. If either the source or destination vertex is not found, or if the
+     * edge does not exist, it returns `null`.
+     */
     removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    /**
+     * The removeEdge function removes an edge from a graph and returns the removed edge, or null if the edge was not
+     * found.
+     * @param {E} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
+     * and `dest`, which represent the source and destination vertices of the edge, respectively.
+     * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+     */
     removeEdge(edge: E): E | null;
+    /**
+     * The function removeAllEdges removes all edges between two vertices.
+     * @param {VertexId | V} src - The `src` parameter represents the source vertex from which the edges will be removed.
+     * It can be either a `VertexId` or a `V` type, which represents the identifier or object of the vertex.
+     * @param {VertexId | V} dest - The `dest` parameter represents the destination vertex of an edge. It can be either a
+     * `VertexId` or a vertex object `V`.
+     * @returns An empty array is being returned.
+     */
     removeAllEdges(src: VertexId | V, dest: VertexId | V): E[];
+    /**
+     * The function `incomingEdgesOf` returns an array of incoming edges for a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `incomingEdgesOf` returns an array of edges (`E[]`).
+     */
     incomingEdgesOf(vertexOrId: V | VertexId): E[];
+    /**
+     * The function `outgoingEdgesOf` returns an array of outgoing edges from a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `outgoingEdgesOf` returns an array of outgoing edges from a given vertex or vertex ID.
+     */
     outgoingEdgesOf(vertexOrId: V | VertexId): E[];
+    /**
+     * The function "degreeOf" returns the total degree of a vertex, which is the sum of its out-degree and in-degree.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns the sum of the out-degree and in-degree of the specified vertex or vertex ID.
+     */
     degreeOf(vertexOrId: VertexId | V): number;
+    /**
+     * The function "inDegreeOf" returns the number of incoming edges for a given vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The number of incoming edges of the specified vertex or vertex ID.
+     */
     inDegreeOf(vertexOrId: VertexId | V): number;
+    /**
+     * The function `outDegreeOf` returns the number of outgoing edges from a given vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The number of outgoing edges from the specified vertex or vertex ID.
+     */
     outDegreeOf(vertexOrId: VertexId | V): number;
+    /**
+     * The function "edgesOf" returns an array of both outgoing and incoming edges of a given vertex or vertex ID.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The function `edgesOf` returns an array of edges.
+     */
     edgesOf(vertexOrId: VertexId | V): E[];
+    /**
+     * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
+     * @param {E} e - E - an edge object
+     * @returns the source vertex of the given edge, or null if the edge does not exist.
+     */
     getEdgeSrc(e: E): V | null;
+    /**
+     * The function "getEdgeDest" returns the vertex associated with the destination of an edge.
+     * @param {E} e - The parameter `e` is of type `E`, which represents an edge in a graph.
+     * @returns either a vertex object (of type V) or null.
+     */
     getEdgeDest(e: E): V | null;
-    getDestinations(vertex: V | null): V[];
+    /**
+     * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
+     * @param {V | VertexId | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
+     * find the destinations. It can be either a `V` object, a `VertexId` (which is a unique identifier for a vertex), or
+     * `null` if we want to find destinations from all vertices.
+     * @returns an array of vertices (V[]).
+     */
+    getDestinations(vertex: V | VertexId | null): V[];
     /**--- start find cycles --- */
     /**
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
+     * The `topologicalSort` function performs a topological sort on a directed graph and returns the sorted vertices in
+     * reverse order, or null if the graph contains a cycle.
+     * @returns The function `topologicalSort()` returns an array of vertices in topological order if there is no cycle in
+     * the graph. If there is a cycle in the graph, it returns `null`.
      */
     topologicalSort(): V[] | null;
     /**--- end find cycles --- */
+    /**
+     * The `edgeSet` function returns an array of all the edges in the graph.
+     * @returns The `edgeSet()` method returns an array of edges (`E[]`).
+     */
     edgeSet(): E[];
+    /**
+     * The function `getNeighbors` returns an array of neighboring vertices for a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns an array of vertices (V[]).
+     */
     getNeighbors(vertexOrId: V | VertexId): V[];
+    /**
+     * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it 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 an array containing two vertices [V, V] if the edge is found in the graph. If the edge is not found, it
+     * returns null.
+     */
     getEndsOfEdge(edge: E): [V, V] | null;
 }