data-structure-typed 1.48.3 → 1.48.4

package/dist/mjs/data-structures/graph/directed-graph.js

@@ -147,34 +147,80 @@ export class DirectedGraph extends AbstractGraph {
         return removed;
     }
     /**
-     * Time Complexity: O(|E|) where |E| is the number of edges
+     * Time Complexity: O(E) where E is the number of edges
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|) where |E| is the number of edges
+     * Time Complexity: O(E) where E is the number of edges
      * Space Complexity: O(1)
      *
-     * The function removes an edge from a graph and returns the removed edge, or undefined if the edge was not found.
-     * @param {EO} 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 `deleteEdge` returns the removed edge (`EO`) if it exists, or `undefined` if the edge does not exist.
-     */
-    deleteEdge(edge) {
+     * The `deleteEdge` function removes an edge from a graph and returns the removed edge.
+     * @param {EO | VertexKey} edgeOrSrcVertexKey - The `edge` parameter can be either an `EO` object (edge object) or
+     * a `VertexKey` (key of a vertex).
+     * @param {VertexKey} [destVertexKey] - The `destVertexKey` parameter is an optional parameter that
+     * represents the key of the destination vertex of the edge. It is used to specify the destination
+     * vertex when the `edge` parameter is a vertex key. If `destVertexKey` is not provided, the function
+     * assumes that the `edge`
+     * @returns the removed edge (EO) or undefined if no edge was removed.
+     */
+    deleteEdge(edgeOrSrcVertexKey, destVertexKey) {
         let removed = undefined;
-        const src = this._getVertex(edge.src);
-        const dest = this._getVertex(edge.dest);
+        let src, dest;
+        if (this.isVertexKey(edgeOrSrcVertexKey)) {
+            if (this.isVertexKey(destVertexKey)) {
+                src = this._getVertex(edgeOrSrcVertexKey);
+                dest = this._getVertex(destVertexKey);
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            src = this._getVertex(edgeOrSrcVertexKey.src);
+            dest = this._getVertex(edgeOrSrcVertexKey.dest);
+        }
         if (src && dest) {
             const srcOutEdges = this._outEdgeMap.get(src);
             if (srcOutEdges && srcOutEdges.length > 0) {
-                arrayRemove(srcOutEdges, (edge) => edge.src === src.key);
+                arrayRemove(srcOutEdges, (edge) => edge.src === src.key && edge.dest === dest?.key);
             }
             const destInEdges = this._inEdgeMap.get(dest);
             if (destInEdges && destInEdges.length > 0) {
-                removed = arrayRemove(destInEdges, (edge) => edge.dest === dest.key)[0];
+                removed = arrayRemove(destInEdges, (edge) => edge.src === src.key && edge.dest === dest.key)[0];
             }
         }
         return removed;
     }
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     *
+     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+     * (`VertexKey`).
+     * @returns The method is returning a boolean value.
+     */
+    deleteVertex(vertexOrKey) {
+        let vertexKey;
+        let vertex;
+        if (this.isVertexKey(vertexOrKey)) {
+            vertex = this.getVertex(vertexOrKey);
+            vertexKey = vertexOrKey;
+        }
+        else {
+            vertex = vertexOrKey;
+            vertexKey = this._getVertexKey(vertexOrKey);
+        }
+        if (vertex) {
+            this._outEdgeMap.delete(vertex);
+            this._inEdgeMap.delete(vertex);
+        }
+        return this._vertices.delete(vertexKey);
+    }
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)

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

@@ -85,18 +85,37 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      */
     deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | undefined;
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * 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 undefined if the edge was not found.
+     * The function `deleteEdge` deletes an edge between two vertices in a graph.
+     * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
+     * either an edge object or a vertex key.
+     * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
+     * parameter that represents the key of the vertex on the other side of the edge. It is used when the
+     * `edgeOrOneSideVertexKey` parameter is a vertex key, and it specifies the key of the vertex on the
+     * other side of the
+     * @returns The `deleteEdge` function returns either the deleted edge object (EO) or `undefined`.
+     */
+    deleteEdge(edgeOrOneSideVertexKey: EO | VertexKey, otherSideVertexKey?: VertexKey): EO | undefined;
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     *
+     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+     * (`VertexKey`).
+     * @returns The method is returning a boolean value.
      */
-    deleteEdge(edge: EO): EO | undefined;
+    deleteVertex(vertexOrKey: VO | VertexKey): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -131,19 +131,82 @@ export class UndirectedGraph extends AbstractGraph {
         return removed;
     }
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * 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 undefined if the edge was not found.
+     * The function `deleteEdge` deletes an edge between two vertices in a graph.
+     * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
+     * either an edge object or a vertex key.
+     * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
+     * parameter that represents the key of the vertex on the other side of the edge. It is used when the
+     * `edgeOrOneSideVertexKey` parameter is a vertex key, and it specifies the key of the vertex on the
+     * other side of the
+     * @returns The `deleteEdge` function returns either the deleted edge object (EO) or `undefined`.
+     */
+    deleteEdge(edgeOrOneSideVertexKey, otherSideVertexKey) {
+        let oneSide, otherSide;
+        if (this.isVertexKey(edgeOrOneSideVertexKey)) {
+            if (this.isVertexKey(otherSideVertexKey)) {
+                oneSide = this._getVertex(edgeOrOneSideVertexKey);
+                otherSide = this._getVertex(otherSideVertexKey);
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            oneSide = this._getVertex(edgeOrOneSideVertexKey.vertices[0]);
+            otherSide = this._getVertex(edgeOrOneSideVertexKey.vertices[1]);
+        }
+        if (oneSide && otherSide) {
+            return this.deleteEdgeBetween(oneSide, otherSide);
+        }
+        else {
+            return;
+        }
+    }
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      */
-    deleteEdge(edge) {
-        return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     *
+     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+     * (`VertexKey`).
+     * @returns The method is returning a boolean value.
+     */
+    deleteVertex(vertexOrKey) {
+        let vertexKey;
+        let vertex;
+        if (this.isVertexKey(vertexOrKey)) {
+            vertex = this.getVertex(vertexOrKey);
+            vertexKey = vertexOrKey;
+        }
+        else {
+            vertex = vertexOrKey;
+            vertexKey = this._getVertexKey(vertexOrKey);
+        }
+        const neighbors = this.getNeighbors(vertexOrKey);
+        if (vertex) {
+            neighbors.forEach(neighbor => {
+                const neighborEdges = this._edges.get(neighbor);
+                if (neighborEdges) {
+                    const restEdges = neighborEdges.filter(edge => {
+                        return !edge.vertices.includes(vertexKey);
+                    });
+                    this._edges.set(neighbor, restEdges);
+                }
+            });
+            this._edges.delete(vertex);
+        }
+        return this._vertices.delete(vertexKey);
     }
     /**
      * Time Complexity: O(1)

package/dist/umd/data-structure-typed.js

@@ -5473,6 +5473,10 @@ var dataStructureTyped = (() => {
         return this._addVertexOnly(newVertex);
       }
     }
+    isVertexKey(potentialKey) {
+      const potentialKeyType = typeof potentialKey;
+      return potentialKeyType === "string" || potentialKeyType === "number";
+    }
     /**
      * Time Complexity: O(1) - Constant time for Map operations.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -6598,34 +6602,77 @@ var dataStructureTyped = (() => {
       return removed;
     }
     /**
-     * Time Complexity: O(|E|) where |E| is the number of edges
+     * Time Complexity: O(E) where E is the number of edges
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|) where |E| is the number of edges
+     * Time Complexity: O(E) where E is the number of edges
      * Space Complexity: O(1)
      *
-     * The function removes an edge from a graph and returns the removed edge, or undefined if the edge was not found.
-     * @param {EO} 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 `deleteEdge` returns the removed edge (`EO`) if it exists, or `undefined` if the edge does not exist.
+     * The `deleteEdge` function removes an edge from a graph and returns the removed edge.
+     * @param {EO | VertexKey} edgeOrSrcVertexKey - The `edge` parameter can be either an `EO` object (edge object) or
+     * a `VertexKey` (key of a vertex).
+     * @param {VertexKey} [destVertexKey] - The `destVertexKey` parameter is an optional parameter that
+     * represents the key of the destination vertex of the edge. It is used to specify the destination
+     * vertex when the `edge` parameter is a vertex key. If `destVertexKey` is not provided, the function
+     * assumes that the `edge`
+     * @returns the removed edge (EO) or undefined if no edge was removed.
      */
-    deleteEdge(edge) {
+    deleteEdge(edgeOrSrcVertexKey, destVertexKey) {
       let removed = void 0;
-      const src = this._getVertex(edge.src);
-      const dest = this._getVertex(edge.dest);
+      let src, dest;
+      if (this.isVertexKey(edgeOrSrcVertexKey)) {
+        if (this.isVertexKey(destVertexKey)) {
+          src = this._getVertex(edgeOrSrcVertexKey);
+          dest = this._getVertex(destVertexKey);
+        } else {
+          return;
+        }
+      } else {
+        src = this._getVertex(edgeOrSrcVertexKey.src);
+        dest = this._getVertex(edgeOrSrcVertexKey.dest);
+      }
       if (src && dest) {
         const srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges && srcOutEdges.length > 0) {
-          arrayRemove(srcOutEdges, (edge2) => edge2.src === src.key);
+          arrayRemove(srcOutEdges, (edge) => edge.src === src.key && edge.dest === (dest == null ? void 0 : dest.key));
         }
         const destInEdges = this._inEdgeMap.get(dest);
         if (destInEdges && destInEdges.length > 0) {
-          removed = arrayRemove(destInEdges, (edge2) => edge2.dest === dest.key)[0];
+          removed = arrayRemove(destInEdges, (edge) => edge.src === src.key && edge.dest === dest.key)[0];
         }
       }
       return removed;
     }
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     *
+     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+     * (`VertexKey`).
+     * @returns The method is returning a boolean value.
+     */
+    deleteVertex(vertexOrKey) {
+      let vertexKey;
+      let vertex;
+      if (this.isVertexKey(vertexOrKey)) {
+        vertex = this.getVertex(vertexOrKey);
+        vertexKey = vertexOrKey;
+      } else {
+        vertex = vertexOrKey;
+        vertexKey = this._getVertexKey(vertexOrKey);
+      }
+      if (vertex) {
+        this._outEdgeMap.delete(vertex);
+        this._inEdgeMap.delete(vertex);
+      }
+      return this._vertices.delete(vertexKey);
+    }
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -7093,19 +7140,78 @@ var dataStructureTyped = (() => {
       return removed;
     }
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * 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 undefined if the edge was not found.
+     * The function `deleteEdge` deletes an edge between two vertices in a graph.
+     * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
+     * either an edge object or a vertex key.
+     * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
+     * parameter that represents the key of the vertex on the other side of the edge. It is used when the
+     * `edgeOrOneSideVertexKey` parameter is a vertex key, and it specifies the key of the vertex on the
+     * other side of the
+     * @returns The `deleteEdge` function returns either the deleted edge object (EO) or `undefined`.
      */
-    deleteEdge(edge) {
-      return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
+    deleteEdge(edgeOrOneSideVertexKey, otherSideVertexKey) {
+      let oneSide, otherSide;
+      if (this.isVertexKey(edgeOrOneSideVertexKey)) {
+        if (this.isVertexKey(otherSideVertexKey)) {
+          oneSide = this._getVertex(edgeOrOneSideVertexKey);
+          otherSide = this._getVertex(otherSideVertexKey);
+        } else {
+          return;
+        }
+      } else {
+        oneSide = this._getVertex(edgeOrOneSideVertexKey.vertices[0]);
+        otherSide = this._getVertex(edgeOrOneSideVertexKey.vertices[1]);
+      }
+      if (oneSide && otherSide) {
+        return this.deleteEdgeBetween(oneSide, otherSide);
+      } else {
+        return;
+      }
+    }
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     *
+     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+     * (`VertexKey`).
+     * @returns The method is returning a boolean value.
+     */
+    deleteVertex(vertexOrKey) {
+      let vertexKey;
+      let vertex;
+      if (this.isVertexKey(vertexOrKey)) {
+        vertex = this.getVertex(vertexOrKey);
+        vertexKey = vertexOrKey;
+      } else {
+        vertex = vertexOrKey;
+        vertexKey = this._getVertexKey(vertexOrKey);
+      }
+      const neighbors = this.getNeighbors(vertexOrKey);
+      if (vertex) {
+        neighbors.forEach((neighbor) => {
+          const neighborEdges = this._edges.get(neighbor);
+          if (neighborEdges) {
+            const restEdges = neighborEdges.filter((edge) => {
+              return !edge.vertices.includes(vertexKey);
+            });
+            this._edges.set(neighbor, restEdges);
+          }
+        });
+        this._edges.delete(vertex);
+      }
+      return this._vertices.delete(vertexKey);
     }
     /**
      * Time Complexity: O(1)