data-structure-typed 1.47.8 → 1.48.0

package/dist/mjs/data-structures/binary-tree/tree-multimap.js

@@ -51,6 +51,48 @@ export class TreeMultimap extends AVLTree {
             comparator: this.comparator, ...options
         });
     }
+    /**
+     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
+     * class.
+     */
+    isNode(exemplar) {
+        return exemplar instanceof TreeMultimapNode;
+    }
+    /**
+     * The function `exemplarToNode` converts an exemplar object into a node object.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+     * the value type and `N` represents the node type.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the node should be created. If not provided, it defaults to 1.
+     * @returns a value of type `N` (the generic type parameter) or `undefined`.
+     */
+    exemplarToNode(exemplar, count = 1) {
+        let node;
+        if (exemplar === undefined || exemplar === null) {
+            return;
+        }
+        else if (this.isNode(exemplar)) {
+            node = exemplar;
+        }
+        else if (this.isEntry(exemplar)) {
+            const [key, value] = exemplar;
+            if (key === undefined || key === null) {
+                return;
+            }
+            else {
+                node = this.createNode(key, value, count);
+            }
+        }
+        else if (this.isNodeKey(exemplar)) {
+            node = this.createNode(exemplar, undefined, count);
+        }
+        else {
+            return;
+        }
+        return node;
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -68,28 +110,9 @@ export class TreeMultimap extends AVLTree {
      * @returns either a node (`N`) or `undefined`.
      */
     add(keyOrNodeOrEntry, count = 1) {
-        let newNode;
-        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
-            return;
-        }
-        else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
-            newNode = keyOrNodeOrEntry;
-        }
-        else if (this.isNodeKey(keyOrNodeOrEntry)) {
-            newNode = this.createNode(keyOrNodeOrEntry, undefined, count);
-        }
-        else if (this.isEntry(keyOrNodeOrEntry)) {
-            const [key, value] = keyOrNodeOrEntry;
-            if (key === undefined || key === null) {
-                return;
-            }
-            else {
-                newNode = this.createNode(key, value, count);
-            }
-        }
-        else {
+        const newNode = this.exemplarToNode(keyOrNodeOrEntry, count);
+        if (newNode === undefined)
             return;
-        }
         const orgNodeCount = newNode?.count || 0;
         const inserted = super.add(newNode);
         if (inserted) {

package/dist/mjs/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/mjs/data-structures/graph/abstract-graph.js

@@ -1021,6 +1021,47 @@ export 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/mjs/data-structures/graph/directed-graph.js

@@ -68,7 +68,7 @@ export class DirectedGraph extends AbstractGraph {
      * @returns a new instance of a DirectedVertex object, casted as type VO.
      */
     createVertex(key, value) {
-        return new DirectedVertex(key, 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/dist/umd/data-structure-typed.js

@@ -5908,6 +5908,47 @@ var dataStructureTyped = (() => {
     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;
@@ -5986,7 +6027,7 @@ var dataStructureTyped = (() => {
      * @returns a new instance of a DirectedVertex object, casted as type VO.
      */
     createVertex(key, value) {
-      return new DirectedVertex(key, value != null ? 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.
@@ -6940,6 +6981,45 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _BinaryTree([], __spreadValues({ iterationType: this.iterationType }, options));
     }
+    /**
+     * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the class N.
+     */
+    isNode(exemplar) {
+      return exemplar instanceof BinaryTreeNode;
+    }
+    /**
+     * The function `exemplarToNode` converts an exemplar of a binary tree node into an actual node
+     * object.
+     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing the exemplar parameter of the
+     * function. It can be any type.
+     * @returns a value of type `N` (which represents a node), or `null`, or `undefined`.
+     */
+    exemplarToNode(exemplar) {
+      if (exemplar === void 0)
+        return;
+      let node;
+      if (exemplar === null) {
+        node = null;
+      } else if (this.isEntry(exemplar)) {
+        const [key, value] = exemplar;
+        if (key === void 0) {
+          return;
+        } else if (key === null) {
+          node = null;
+        } else {
+          node = this.createNode(key, value);
+        }
+      } else if (this.isNode(exemplar)) {
+        node = exemplar;
+      } else if (this.isNodeKey(exemplar)) {
+        node = this.createNode(exemplar);
+      } else {
+        return;
+      }
+      return node;
+    }
     /**
      * The function checks if a given value is an entry in a binary tree node.
      * @param kne - BTNodeExemplar<V, N> - A generic type representing a node in a binary tree. It has
@@ -6962,16 +7042,19 @@ var dataStructureTyped = (() => {
      * @returns The function `add` returns the inserted node (`N`), `null`, or `undefined`.
      */
     add(keyOrNodeOrEntry) {
-      let inserted, needInsert;
-      const _bfs = (root, newNode) => {
+      let inserted;
+      const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+      if (newNode === void 0)
+        return;
+      const _bfs = (root, newNode2) => {
         const queue = new Queue([root]);
         while (queue.size > 0) {
           const cur = queue.shift();
-          if (newNode && cur.key === newNode.key) {
-            this._replaceNode(cur, newNode);
-            return newNode;
+          if (newNode2 && cur.key === newNode2.key) {
+            this._replaceNode(cur, newNode2);
+            return newNode2;
           }
-          const inserted2 = this._addTo(newNode, cur);
+          const inserted2 = this._addTo(newNode2, cur);
           if (inserted2 !== void 0)
             return inserted2;
           if (cur.left)
@@ -6980,29 +7063,11 @@ var dataStructureTyped = (() => {
             queue.push(cur.right);
         }
       };
-      if (keyOrNodeOrEntry === null) {
-        needInsert = null;
-      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
-        needInsert = this.createNode(keyOrNodeOrEntry);
-      } else if (keyOrNodeOrEntry instanceof BinaryTreeNode) {
-        needInsert = keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value] = keyOrNodeOrEntry;
-        if (key === void 0) {
-          return;
-        } else if (key === null) {
-          needInsert = null;
-        } else {
-          needInsert = this.createNode(key, value);
-        }
-      } else {
-        return;
-      }
       if (this.root) {
-        inserted = _bfs(this.root, needInsert);
+        inserted = _bfs(this.root, newNode);
       } else {
-        this._setRoot(needInsert);
-        if (needInsert) {
+        this._setRoot(newNode);
+        if (newNode) {
           this._size = 1;
         } else {
           this._size = 0;
@@ -8508,6 +8573,40 @@ var dataStructureTyped = (() => {
         comparator: this.comparator
       }, options));
     }
+    /**
+     * The function checks if an exemplar is an instance of BSTNode.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
+     */
+    isNode(exemplar) {
+      return exemplar instanceof BSTNode;
+    }
+    /**
+     * The function `exemplarToNode` takes an exemplar and returns a corresponding node if the exemplar
+     * is valid, otherwise it returns undefined.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a variable `node` which is of type `N` or `undefined`.
+     */
+    exemplarToNode(exemplar) {
+      let node;
+      if (exemplar === null || exemplar === void 0) {
+        return;
+      } else if (this.isNode(exemplar)) {
+        node = exemplar;
+      } else if (this.isEntry(exemplar)) {
+        const [key, value] = exemplar;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          node = this.createNode(key, value);
+        }
+      } else if (this.isNodeKey(exemplar)) {
+        node = this.createNode(exemplar);
+      } else {
+        return;
+      }
+      return node;
+    }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -8523,24 +8622,9 @@ var dataStructureTyped = (() => {
      * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
      */
     add(keyOrNodeOrEntry) {
-      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
-        return void 0;
-      }
-      let newNode;
-      if (keyOrNodeOrEntry instanceof BSTNode) {
-        newNode = keyOrNodeOrEntry;
-      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
-        newNode = this.createNode(keyOrNodeOrEntry);
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value] = keyOrNodeOrEntry;
-        if (key === void 0 || key === null) {
-          return;
-        } else {
-          newNode = this.createNode(key, value);
-        }
-      } else {
+      const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+      if (newNode === void 0)
         return;
-      }
       if (this.root === void 0) {
         this._setRoot(newNode);
         this._size++;
@@ -9504,6 +9588,14 @@ var dataStructureTyped = (() => {
         comparator: this.comparator
       }, options));
     }
+    /**
+     * The function checks if an exemplar is an instance of AVLTreeNode.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
+     */
+    isNode(exemplar) {
+      return exemplar instanceof AVLTreeNode;
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -9925,70 +10017,93 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
+     * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
+     * class.
      */
+    isNode(exemplar) {
+      return exemplar instanceof RedBlackTreeNode;
+    }
     /**
-     * The function adds a node to a Red-Black Tree data structure.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @returns The method `add` returns either an instance of `N` (the node that was added) or
-     * `undefined`.
+     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
+     * otherwise it returns undefined.
+     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
+     * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
+     * that is not a valid exemplar.
+     * @returns a variable `node` which is of type `N | undefined`.
      */
-    add(keyOrNodeOrEntry) {
+    exemplarToNode(exemplar) {
       let node;
-      if (this.isNodeKey(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, void 0, 1 /* RED */);
-      } else if (keyOrNodeOrEntry instanceof RedBlackTreeNode) {
-        node = keyOrNodeOrEntry;
-      } else if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
+      if (exemplar === null || exemplar === void 0) {
         return;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value] = keyOrNodeOrEntry;
+      } else if (this.isNode(exemplar)) {
+        node = exemplar;
+      } else if (this.isEntry(exemplar)) {
+        const [key, value] = exemplar;
         if (key === void 0 || key === null) {
           return;
         } else {
           node = this.createNode(key, value, 1 /* RED */);
         }
+      } else if (this.isNodeKey(exemplar)) {
+        node = this.createNode(exemplar, void 0, 1 /* RED */);
       } else {
         return;
       }
-      node.left = this.Sentinel;
-      node.right = this.Sentinel;
+      return node;
+    }
+    /**
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     */
+    /**
+     * The function adds a node to a Red-Black Tree data structure.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
+     * @returns The method `add` returns either an instance of `N` (the node that was added) or
+     * `undefined`.
+     */
+    add(keyOrNodeOrEntry) {
+      const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+      if (newNode === void 0)
+        return;
+      newNode.left = this.Sentinel;
+      newNode.right = this.Sentinel;
       let y = void 0;
       let x = this.root;
       while (x !== this.Sentinel) {
         y = x;
         if (x) {
-          if (node.key < x.key) {
+          if (newNode.key < x.key) {
             x = x.left;
-          } else if (node.key > x.key) {
+          } else if (newNode.key > x.key) {
             x = x == null ? void 0 : x.right;
           } else {
-            if (node !== x) {
-              this._replaceNode(x, node);
+            if (newNode !== x) {
+              this._replaceNode(x, newNode);
             }
             return;
           }
         }
       }
-      node.parent = y;
+      newNode.parent = y;
       if (y === void 0) {
-        this._setRoot(node);
-      } else if (node.key < y.key) {
-        y.left = node;
+        this._setRoot(newNode);
+      } else if (newNode.key < y.key) {
+        y.left = newNode;
       } else {
-        y.right = node;
+        y.right = newNode;
       }
-      if (node.parent === void 0) {
-        node.color = 0 /* BLACK */;
+      if (newNode.parent === void 0) {
+        newNode.color = 0 /* BLACK */;
         this._size++;
         return;
       }
-      if (node.parent.parent === void 0) {
+      if (newNode.parent.parent === void 0) {
         this._size++;
         return;
       }
-      this._fixInsert(node);
+      this._fixInsert(newNode);
       this._size++;
     }
     /**
@@ -10439,6 +10554,43 @@ var dataStructureTyped = (() => {
         comparator: this.comparator
       }, options));
     }
+    /**
+     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
+     * class.
+     */
+    isNode(exemplar) {
+      return exemplar instanceof TreeMultimapNode;
+    }
+    /**
+     * The function `exemplarToNode` converts an exemplar object into a node object.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+     * the value type and `N` represents the node type.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the node should be created. If not provided, it defaults to 1.
+     * @returns a value of type `N` (the generic type parameter) or `undefined`.
+     */
+    exemplarToNode(exemplar, count = 1) {
+      let node;
+      if (exemplar === void 0 || exemplar === null) {
+        return;
+      } else if (this.isNode(exemplar)) {
+        node = exemplar;
+      } else if (this.isEntry(exemplar)) {
+        const [key, value] = exemplar;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          node = this.createNode(key, value, count);
+        }
+      } else if (this.isNodeKey(exemplar)) {
+        node = this.createNode(exemplar, void 0, count);
+      } else {
+        return;
+      }
+      return node;
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -10456,23 +10608,9 @@ var dataStructureTyped = (() => {
      * @returns either a node (`N`) or `undefined`.
      */
     add(keyOrNodeOrEntry, count = 1) {
-      let newNode;
-      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
-        return;
-      } else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
-        newNode = keyOrNodeOrEntry;
-      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
-        newNode = this.createNode(keyOrNodeOrEntry, void 0, count);
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value] = keyOrNodeOrEntry;
-        if (key === void 0 || key === null) {
-          return;
-        } else {
-          newNode = this.createNode(key, value, count);
-        }
-      } else {
+      const newNode = this.exemplarToNode(keyOrNodeOrEntry, count);
+      if (newNode === void 0)
         return;
-      }
       const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
       const inserted = super.add(newNode);
       if (inserted) {