data-structure-typed 1.49.8 → 1.50.0

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

@@ -585,32 +585,49 @@ var dataStructureTyped = (() => {
   // src/data-structures/hash/hash-map.ts
   var HashMap = class _HashMap extends IterableEntryBase {
     /**
-     * The constructor function initializes a new instance of a class with optional entries and options.
-     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
-     * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
-     * key-value pairs.
-     * @param [options] - The `options` parameter is an optional object that can contain additional
-     * configuration options for the constructor. In this case, it has one property:
+     * The constructor function initializes a HashMap object with an optional initial collection and
+     * options.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`. It is an optional parameter and its default value is an empty array `[]`.
+     * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(entries = [], options) {
+    constructor(rawCollection = [], options) {
       super();
       __publicField(this, "_store", {});
       __publicField(this, "_objMap", /* @__PURE__ */ new Map());
+      __publicField(this, "_toEntryFn", (rawElement) => {
+        if (this.isEntry(rawElement)) {
+          return rawElement;
+        } else {
+          throw new Error(
+            "If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
+          );
+        }
+      });
       __publicField(this, "_size", 0);
       __publicField(this, "_hashFn", (key) => String(key));
       if (options) {
-        const { hashFn } = options;
+        const { hashFn, toEntryFn } = options;
         if (hashFn) {
           this._hashFn = hashFn;
         }
+        if (toEntryFn) {
+          this._toEntryFn = toEntryFn;
+        }
       }
-      if (entries) {
-        this.setMany(entries);
+      if (rawCollection) {
+        this.setMany(rawCollection);
       }
     }
+    get toEntryFn() {
+      return this._toEntryFn;
+    }
     get size() {
       return this._size;
     }
+    isEntry(rawElement) {
+      return Array.isArray(rawElement) && rawElement.length === 2;
+    }
     isEmpty() {
       return this.size === 0;
     }
@@ -644,14 +661,18 @@ var dataStructureTyped = (() => {
       return true;
     }
     /**
-     * The function "setMany" sets multiple key-value pairs in a map.
-     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two entries: the key and the value.
+     * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
+     * pair using a mapping function, and sets each key-value pair in the current object.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`.
+     * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(entries) {
+    setMany(rawCollection) {
       const results = [];
-      for (const [key, value] of entries)
+      for (const rawEle of rawCollection) {
+        const [key, value] = this.toEntryFn(rawEle);
         results.push(this.set(key, value));
+      }
       return results;
     }
     /**
@@ -7115,7 +7136,7 @@ var dataStructureTyped = (() => {
         }
       } else if (this.isNode(keyOrNodeOrEntry)) {
         node = keyOrNodeOrEntry;
-      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+      } else if (!this.isNode(keyOrNodeOrEntry)) {
         node = this.createNode(keyOrNodeOrEntry, value);
       } else {
         return;
@@ -7203,15 +7224,6 @@ var dataStructureTyped = (() => {
     isNodeOrNull(node) {
       return this.isRealNode(node) || node === null;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof BinaryTreeNode);
-    }
     /**
      * Time Complexity O(log n) - O(n)
      * Space Complexity O(1)
@@ -7756,7 +7768,7 @@ var dataStructureTyped = (() => {
      *
      * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
      * structure, with the option to reverse the order of the nodes.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginNode - The `beginRoot` parameter represents the
      * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
      * `null`, or `undefined`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
@@ -7764,16 +7776,16 @@ var dataStructureTyped = (() => {
      * reversed before returning it. If `isReverse` is set to `false`, the path will be returned as is
      * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
      */
-    getPathToRoot(beginRoot, isReverse = true) {
+    getPathToRoot(beginNode, isReverse = true) {
       const result = [];
-      beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot)
+      beginNode = this.ensureNode(beginNode);
+      if (!beginNode)
         return result;
-      while (beginRoot.parent) {
-        result.push(beginRoot);
-        beginRoot = beginRoot.parent;
+      while (beginNode.parent) {
+        result.push(beginNode);
+        beginNode = beginNode.parent;
       }
-      result.push(beginRoot);
+      result.push(beginNode);
       return isReverse ? result.reverse() : result;
     }
     /**
@@ -7908,65 +7920,6 @@ var dataStructureTyped = (() => {
         return isStandardBST || isInverseBST;
       }
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     *
-     * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
-     * node, either recursively or iteratively.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the subtree traversal. It takes a single parameter, which is the current node being traversed, and
-     * returns a value of any type.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node or key from which the subtree traversal should begin. It can be of type `K`,
-     * `N`, `null`, or `undefined`. If not provided, the `root` property of the current object is used as
-     * the default value.
-     * @param iterationType - The `iterationType` parameter determines the type of traversal to be
-     * performed on the subtree. It can have two possible values:
-     * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-     * whether to include null values in the traversal. If `includeNull` is set to `true`, the
-     * traversal will include null values, otherwise it will skip them.
-     * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
-     * the `callback` function on each node in the subtree. The type of the array nodes is determined
-     * by the return type of the `callback` function.
-     */
-    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNode(beginRoot);
-      const ans = [];
-      if (!beginRoot)
-        return ans;
-      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
-        const _traverse = (cur) => {
-          if (cur !== void 0) {
-            ans.push(callback(cur));
-            if (includeNull) {
-              cur && this.isNodeOrNull(cur.left) && _traverse(cur.left);
-              cur && this.isNodeOrNull(cur.right) && _traverse(cur.right);
-            } else {
-              cur && cur.left && _traverse(cur.left);
-              cur && cur.right && _traverse(cur.right);
-            }
-          }
-        };
-        _traverse(beginRoot);
-      } else {
-        const stack = [beginRoot];
-        while (stack.length > 0) {
-          const cur = stack.pop();
-          if (cur !== void 0) {
-            ans.push(callback(cur));
-            if (includeNull) {
-              cur && this.isNodeOrNull(cur.right) && stack.push(cur.right);
-              cur && this.isNodeOrNull(cur.left) && stack.push(cur.left);
-            } else {
-              cur && cur.right && stack.push(cur.right);
-              cur && cur.left && stack.push(cur.left);
-            }
-          }
-        }
-      }
-      return ans;
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8738,7 +8691,7 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value2);
         }
-      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+      } else if (!this.isNode(keyOrNodeOrEntry)) {
         node = this.createNode(keyOrNodeOrEntry, value);
       } else {
         return;
@@ -8775,15 +8728,6 @@ var dataStructureTyped = (() => {
       }
       return res;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof BSTNode);
-    }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, N>`.
@@ -8941,39 +8885,6 @@ var dataStructureTyped = (() => {
       }
       return inserted;
     }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
-     */
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-     * leftmost node if the comparison result is greater than.
-     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
-     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-     * the key of the leftmost node if the comparison result is greater than, and the key of the
-     * rightmost node otherwise. If no node is found, it returns 0.
-     */
-    lastKey(beginRoot = this.root) {
-      let current = this.ensureNode(beginRoot);
-      if (!current)
-        return void 0;
-      if (this._variant === "STANDARD" /* STANDARD */) {
-        while (current.right !== void 0) {
-          current = current.right;
-        }
-      } else {
-        while (current.left !== void 0) {
-          current = current.left;
-        }
-      }
-      return current.key;
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -9102,6 +9013,133 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    // /**
+    //  * The function overrides the subTreeTraverse method and returns the result of calling the super
+    //  * method with the provided arguments.
+    //  * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+    //  * the subtree traversal. It should accept a single parameter of type `N`, which represents a node in
+    //  * the tree. The return type of the callback function can be any type.
+    //  * @param beginRoot - The `beginRoot` parameter is the starting point for traversing the subtree. It
+    //  * can be either a key, a node, or an entry.
+    //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+    //  * be performed during the traversal of the subtree. It can have one of the following values:
+    //  * @returns The method is returning an array of the return type of the callback function.
+    //  */
+    // override subTreeTraverse<C extends BTNCallback<N>>(
+    //   callback: C = this._defaultOneParamCallback as C,
+    //   beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+    //   iterationType = this.iterationType
+    // ): ReturnType<C>[] {
+    //   return super.subTreeTraverse(callback, beginRoot, iterationType, false);
+    // }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the depth-first search method and returns an array of the return types of
+     * the callback function.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node
+     * during the depth-first search traversal. It is an optional parameter and if not provided, a
+     * default callback function will be used.
+     * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter specifies the order in which the
+     * nodes are visited during the depth-first search. It can have one of the following values:
+     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for the
+     * Depth-First Search (DFS) traversal. It can be either a key, a node, or an entry in the tree. If no
+     * value is provided, the DFS traversal will start from the root of the tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter specifies the type of
+     * iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
+     * following values:
+     * @returns The method is returning an array of the return type of the callback function.
+     */
+    dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE" /* ITERATIVE */) {
+      return super.dfs(callback, pattern, beginRoot, iterationType, false);
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the breadth-first search method and returns an array of the return types of
+     * the callback function.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node
+     * visited during the breadth-first search traversal. It is an optional parameter and if not
+     * provided, a default callback function will be used.
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the breadth-first search
+     * traversal. It can be either a key, a node, or an entry in the tree. If not specified, the root of
+     * the tree is used as the starting point.
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed during the breadth-first search (BFS) traversal. It determines the order in which the
+     * nodes are visited.
+     * @returns The method is returning an array of the return type of the callback function.
+     */
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+      return super.bfs(callback, beginRoot, iterationType, false);
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the listLevels method and returns an array of arrays containing the return
+     * type of the callback function for each level of the tree.
+     * @param {C} callback - The `callback` parameter is a generic type `C` that extends
+     * `BTNCallback<N>`. It represents a callback function that will be called for each node in the tree
+     * during the level listing process.
+     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for listing the
+     * levels of a binary tree. It can be either a key, a node, or an entry in the binary tree. If not
+     * provided, the root of the binary tree is used as the starting point.
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed on the tree. It determines the order in which the nodes are visited during the
+     * iteration.
+     * @returns The method is returning a two-dimensional array of the return type of the callback
+     * function.
+     */
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+      return super.listLevels(callback, beginRoot, iterationType, false);
+    }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
+     * leftmost node if the comparison result is greater than.
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+     * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
+     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
+     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
+     * the key of the leftmost node if the comparison result is greater than, and the key of the
+     * rightmost node otherwise. If no node is found, it returns 0.
+     */
+    lastKey(beginRoot = this.root) {
+      let current = this.ensureNode(beginRoot);
+      if (!current)
+        return void 0;
+      if (this._variant === "STANDARD" /* STANDARD */) {
+        while (current.right !== void 0) {
+          current = current.right;
+        }
+      } else {
+        while (current.left !== void 0) {
+          current = current.left;
+        }
+      }
+      return current.key;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -9786,15 +9824,6 @@ var dataStructureTyped = (() => {
     isNode(keyOrNodeOrEntry) {
       return keyOrNodeOrEntry instanceof AVLTreeNode;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof AVLTreeNode);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -10243,7 +10272,7 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value2, 1 /* RED */);
         }
-      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+      } else if (!this.isNode(keyOrNodeOrEntry)) {
         node = this.createNode(keyOrNodeOrEntry, value, 1 /* RED */);
       } else {
         return;
@@ -10268,15 +10297,6 @@ var dataStructureTyped = (() => {
         return false;
       return node instanceof RedBlackTreeNode;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof RedBlackTreeNode);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -10736,7 +10756,7 @@ var dataStructureTyped = (() => {
     // TODO the _count is not accurate after nodes count modified
     get count() {
       let sum = 0;
-      this.subTreeTraverse((node) => sum += node.count);
+      this.dfs((node) => sum += node.count);
       return sum;
     }
     /**
@@ -10781,7 +10801,7 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value2, count);
         }
-      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+      } else if (!this.isNode(keyOrNodeOrEntry)) {
         node = this.createNode(keyOrNodeOrEntry, value, count);
       } else {
         return;
@@ -10797,15 +10817,6 @@ var dataStructureTyped = (() => {
     isNode(keyOrNodeOrEntry) {
       return keyOrNodeOrEntry instanceof TreeMultimapNode;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof TreeMultimapNode);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)