undirected-graph-typed 1.47.8 → 1.47.9

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

@@ -443,6 +443,11 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @returns the bridges found using the Tarjan algorithm.
      */
     getBridges(): EO[];
+    [Symbol.iterator](): Iterator<[VertexKey, V | undefined]>;
+    forEach(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => void): void;
+    filter(predicate: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => boolean): [VertexKey, V | undefined][];
+    map<T>(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T): T[];
+    reduce<T>(callback: (accumulator: T, entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T, initialValue: T): T;
     protected abstract _addEdgeOnly(edge: EO): boolean;
     protected _addVertexOnly(newVertex: VO): boolean;
     protected _getVertex(vertexOrKey: VertexKey | VO): VO | undefined;

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

@@ -1028,6 +1028,47 @@ class AbstractGraph {
     getBridges() {
         return this.tarjan(false, true, false, false).bridges;
     }
+    *[Symbol.iterator]() {
+        for (const vertex of this._vertices.values()) {
+            yield [vertex.key, vertex.value];
+        }
+    }
+    forEach(callback) {
+        let index = 0;
+        for (const vertex of this) {
+            callback(vertex, index, this._vertices);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const filtered = [];
+        let index = 0;
+        for (const entry of this) {
+            if (predicate(entry, index, this._vertices)) {
+                filtered.push(entry);
+            }
+            index++;
+        }
+        return filtered;
+    }
+    map(callback) {
+        const mapped = [];
+        let index = 0;
+        for (const entry of this) {
+            mapped.push(callback(entry, index, this._vertices));
+            index++;
+        }
+        return mapped;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const entry of this) {
+            accumulator = callback(accumulator, entry, index, this._vertices);
+            index++;
+        }
+        return accumulator;
+    }
     _addVertexOnly(newVertex) {
         if (this.hasVertex(newVertex)) {
             return false;

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

@@ -71,7 +71,7 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
      * @returns a new instance of a DirectedVertex object, casted as type VO.
      */
     createVertex(key, value) {
-        return new DirectedVertex(key, value !== null && value !== void 0 ? value : key);
+        return new DirectedVertex(key, value);
     }
     /**
      * 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undirected-graph-typed",
-  "version": "1.47.8",
+  "version": "1.47.9",
   "description": "Undirected Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -145,6 +145,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.47.8"
+    "data-structure-typed": "^1.47.9"
   }
 }

package/src/data-structures/graph/abstract-graph.ts

@@ -1159,6 +1159,52 @@ export abstract class AbstractGraph<
     return this.tarjan(false, true, false, false).bridges;
   }
 
+  * [Symbol.iterator](): Iterator<[VertexKey, V | undefined]> {
+    for (const vertex of this._vertices.values()) {
+      yield [vertex.key, vertex.value];
+    }
+  }
+
+  forEach(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => void): void {
+    let index = 0;
+    for (const vertex of this) {
+      callback(vertex, index, this._vertices);
+      index++;
+    }
+  }
+
+  filter(predicate: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => boolean): [VertexKey, V | undefined][] {
+    const filtered: [VertexKey, V | undefined][] = [];
+    let index = 0;
+    for (const entry of this) {
+      if (predicate(entry, index, this._vertices)) {
+        filtered.push(entry);
+      }
+      index++;
+    }
+    return filtered;
+  }
+
+  map<T>(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T): T[] {
+    const mapped: T[] = [];
+    let index = 0;
+    for (const entry of this) {
+      mapped.push(callback(entry, index, this._vertices));
+      index++;
+    }
+    return mapped;
+  }
+
+  reduce<T>(callback: (accumulator: T, entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T, initialValue: T): T {
+    let accumulator: T = initialValue;
+    let index = 0;
+    for (const entry of this) {
+      accumulator = callback(accumulator, entry, index, this._vertices);
+      index++;
+    }
+    return accumulator;
+  }
+
   protected abstract _addEdgeOnly(edge: EO): boolean;
 
   protected _addVertexOnly(newVertex: VO): boolean {

package/src/data-structures/graph/directed-graph.ts

@@ -87,7 +87,7 @@ export class DirectedGraph<
    * @returns a new instance of a DirectedVertex object, casted as type VO.
    */
   createVertex(key: VertexKey, value?: V): VO {
-    return new DirectedVertex(key, value ?? key) as VO;
+    return new DirectedVertex(key, value) as VO;
   }
 
   /**