undirected-graph-typed 1.52.5 → 1.52.8

package/dist/data-structures/binary-tree/bst.d.ts

@@ -1,12 +1,11 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNKeyOrNodeOrEntry, Comparator, CP, DFSOrderPattern, IterationType, OptBSTN } from '../../types';
-import { BTNEntry } from '../../types';
+import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNEntry, BTNKeyOrNodeOrEntry, BTNPredicate, Comparator, CP, DFSOrderPattern, IterationType, OptBSTN } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, NODE> {
@@ -50,13 +49,13 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
 export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, R, NODE, TREE> = BST<K, V, R, NODE, BSTNested<K, V, R, NODE>>> extends BinaryTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * This is the constructor function for a Binary Search Tree class in TypeScript.
-     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
      * iterable that can contain either keys, nodes, entries, or raw elements. These elements will be
      * added to the binary search tree during the construction of the object.
      * @param [options] - An optional object that contains additional options for the Binary Search Tree.
      * It can include a comparator function that defines the order of the elements in the tree.
      */
-    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: BSTOptions<K, V, R>);
+    constructor(keysOrNodesOrEntriesOrRaws?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: BSTOptions<K, V, R>);
     protected _root?: NODE;
     /**
      * The function returns the root node of a tree structure.
@@ -79,25 +78,25 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * following properties:
      * @returns a new instance of the BST class with the provided options.
      */
-    createTree(options?: Partial<BSTOptions<K, V, R>>): TREE;
+    createTree(options?: BSTOptions<K, V, R>): TREE;
     /**
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - A variable that can be of
      * type R or BTNKeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
      * element.
      * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
      * value associated with a key in a key-value pair.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): OptBSTN<NODE>;
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): OptBSTN<NODE>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, which represents the key, node,
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
      * parameter that specifies the type of iteration to be used when ensuring a node. It has a default
@@ -105,35 +104,43 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @returns The method is returning either the node that was ensured or `undefined` if the node could
      * not be ensured.
      */
-    ensureNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBSTN<NODE>;
+    ensureNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, iterationType?: IterationType): OptBSTN<NODE>;
     /**
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
      * an instance of the `BSTNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
+    isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE;
+    /**
+     * The function "override isKey" checks if a key is comparable based on a given comparator.
+     * @param {any} key - The `key` parameter is a value that will be checked to determine if it is of
+     * type `K`.
+     * @returns The `override isKey(key: any): key is K` function is returning a boolean value based on
+     * the result of the `isComparable` function with the condition `this.comparator !==
+     * this._DEFAULT_COMPARATOR`.
+     */
     isKey(key: any): key is K;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
      */
-    add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
+    add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): boolean;
     /**
      * Time Complexity: O(k log n)
      * Space Complexity: O(k + log n)
      *
      * The `addMany` function in TypeScript adds multiple keys or nodes to a data structure and returns
      * an array indicating whether each key or node was successfully inserted.
-     * @param keysOrNodesOrEntriesOrRawElements - An iterable containing keys, nodes, entries, or raw
+     * @param keysOrNodesOrEntriesOrRaws - An iterable containing keys, nodes, entries, or raw
      * elements to be added to the data structure.
      * @param [values] - An optional iterable of values to be associated with the keys or nodes being
      * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
@@ -148,52 +155,52 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @returns The function `addMany` returns an array of booleans indicating whether each element was
      * successfully inserted into the data structure.
      */
-    addMany(keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
+    addMany(keysOrNodesOrEntriesOrRaws: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
      *
-     * The `getNodes` function in TypeScript retrieves nodes from a binary tree based on a given
-     * identifier and callback function.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
-     * want to search for in the binary tree. It can be of any type that is returned by the callback
-     * function.
-     * @param {C} callback - The `callback` parameter is a function that takes a node as input and
-     * returns a value. This value is used to identify the nodes that match the given identifier. The
-     * `callback` function is optional and defaults to `this._DEFAULT_CALLBACK`.
-     * @param [onlyOne=false] - A boolean value indicating whether to return only the first matching node
-     * or all matching nodes. If set to true, only the first matching node will be returned. If set to
-     * false, all matching nodes will be returned. The default value is false.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
-     * point for the search in the binary tree. It can be either a node object, a key-value pair, or an
-     * entry object. If it is not provided, the `root` of the binary tree is used as the starting point.
-     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
-     * iteration to be performed. It can have two possible values:
-     * @returns The method `getNodes` returns an array of `NODE` objects.
+     * The function `getNodes` in TypeScript overrides the base class method to retrieve nodes based on a
+     * given predicate and iteration type.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * parameter in the `getNodes` method is used to filter the nodes that will be returned. It can be a
+     * key, a node, an entry, or a custom predicate function that determines whether a node should be
+     * included in the result.
+     * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` method is a boolean flag that
+     * determines whether to return only the first node that matches the predicate (`true`) or all nodes
+     * that match the predicate (`false`). If `onlyOne` is set to `true`, the method will stop iterating
+     * and
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * `getNodes` method is used to specify the starting point for traversing the tree when searching for
+     * nodes that match a given predicate. It represents the root node of the subtree where the search
+     * should begin. If not explicitly provided, the default value for `begin
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` method
+     * specifies the type of iteration to be performed when traversing the nodes of a binary tree. It can
+     * have two possible values:
+     * @returns The `getNodes` method returns an array of nodes that satisfy the given predicate.
      */
-    getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNodes(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>, onlyOne?: boolean, beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R, iterationType?: IterationType): NODE[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `getNode` returns the first node that matches the given identifier and callback
-     * function in a binary search tree.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
-     * want to search for in the binary search tree. It can be of any type that is compatible with the
-     * type returned by the callback function.
-     * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
-     * node matches the desired criteria. It should be a function that takes a node as an argument and
-     * returns a boolean value indicating whether the node matches the criteria or not. If no callback is
-     * provided, the default callback will be
-     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
-     * search tree. It can be either a key or a node. If it is a key, the search will start from the node
-     * with that key. If it is a node, the search will start from that node.
-     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
-     * of iteration to be performed when searching for nodes in the binary search tree. It can have one
-     * of the following values:
-     * @returns The method is returning a NODE object or undefined.
+     * This function retrieves a node based on a given predicate within a binary search tree structure.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * parameter can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, `R`, or `BTNPredicate<NODE>`.
+     * @param {R | BSTNKeyOrNode<K, NODE>} beginRoot - The `beginRoot` parameter in the `getNode` method
+     * is used to specify the starting point for searching nodes in the binary search tree. If no
+     * specific starting point is provided, the default value is set to `this._root`, which is the root
+     * node of the binary search tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNode` method is a
+     * parameter that specifies the type of iteration to be used. It has a default value of
+     * `this.iterationType`, which means it will use the iteration type defined in the class instance if
+     * no value is provided when calling the method.
+     * @returns The `getNode` method is returning an optional binary search tree node (`OptBSTN<NODE>`).
+     * It is using the `getNodes` method to find the node based on the provided predicate, beginning at
+     * the specified root node (`beginRoot`) and using the specified iteration type. The method then
+     * returns the first node found or `undefined` if no node is found.
      */
-    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: R | BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): OptBSTN<NODE>;
+    getNode(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>, beginRoot?: R | BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): OptBSTN<NODE>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -216,11 +223,11 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * 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 defaults to
-     * `this._DEFAULT_CALLBACK`. The type `C` represents the type of the callback function.
+     * `this._DEFAULT_BTN_CALLBACK`. The type `C` represents the type of the callback function.
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
      * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -228,7 +235,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
+    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -238,7 +245,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -246,7 +253,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * the following values:
      * @returns an array of the return type of the callback function.
      */
-    bfs<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
+    bfs<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -256,7 +263,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
      * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -265,7 +272,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
-    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: BTNKeyOrNodeOrEntry<K, V, NODE> | R, iterationType?: IterationType): ReturnType<C>[][];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -278,7 +285,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -287,7 +294,7 @@ export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTN
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse<C extends BTNCallback<NODE>>(callback?: C, lesserOrGreater?: CP, targetNode?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<NODE>>(callback?: C, lesserOrGreater?: CP, targetNode?: BTNKeyOrNodeOrEntry<K, V, NODE> | R, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)