data-structure-typed 1.41.5 → 1.41.7

package/dist/cjs/src/utils/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/utils/utils.ts"],"names":[],"mappings":"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"}

package/dist/mjs/{data-structures → src/data-structures}/binary-tree/avl-tree.d.ts

@@ -50,7 +50,7 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `((node: N) => node.key)`
+     * `this.defaultOneParamCallback`
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C): BinaryTreeDeletedResult<N>[];

package/dist/mjs/{data-structures → src/data-structures}/binary-tree/avl-tree.js

@@ -63,10 +63,10 @@ class AVLTree extends bst_1.BST {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `((node: N) => node.key)`
+     * `this.defaultOneParamCallback`
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    delete(identifier, callback = ((node) => node.key)) {
+    delete(identifier, callback = this.defaultOneParamCallback) {
         if (identifier instanceof AVLTreeNode)
             callback = (node => node);
         const deletedResults = super.delete(identifier, callback);

package/dist/mjs/{data-structures → src/data-structures}/binary-tree/binary-tree.d.ts

@@ -79,6 +79,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * Get the number of nodes in the binary tree.
      */
     get size(): number;
+    protected defaultOneParamCallback: (node: N) => number;
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {BTNKey} key - The key for the new node.
@@ -257,7 +258,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * function on each node according to a specified order pattern.
      * @param callback - The `callback` parameter is a function that will be called on each node during
      * the depth-first search traversal. It takes a node as input and returns a value. The default value
-     * is `((node: N) => node.key)`, which is a callback function defined elsewhere in the code.
+     * is `this.defaultOneParamCallback`, which is a callback function defined elsewhere in the code.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
      * nodes are visited during the depth-first search. There are three possible values for `pattern`:
      * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the depth-first
@@ -273,7 +274,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * function on each node.
      * @param callback - The `callback` parameter is a function that will be called for each node in the
      * breadth-first search. It takes a node of type `N` as its argument and returns a value of type
-     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `((node: N) => node.key)
+     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this.defaultOneParamCallback
      * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
      * search. It determines from which node the search will begin. If `beginRoot` is `null`, the search
      * will not be performed and an empty array will be returned.
@@ -317,7 +318,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * algorithm and returns an array of values obtained by applying a callback function to each node.
      * @param callback - The `callback` parameter is a function that will be called on each node in the
      * tree. It takes a node of type `N` as input and returns a value of type `ReturnType<BTNCallback<N>>`. The
-     * default value for this parameter is `((node: N) => node.key)`.
+     * default value for this parameter is `this.defaultOneParamCallback`.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:

package/dist/mjs/{data-structures → src/data-structures}/binary-tree/binary-tree.js

@@ -121,6 +121,7 @@ class BinaryTree {
     get size() {
         return this._size;
     }
+    defaultOneParamCallback = (node) => node.key;
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {BTNKey} key - The key for the new node.
@@ -256,9 +257,9 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `((node: N) => node.key)`, which
+     * `this.defaultOneParamCallback`, which
      */
-    delete(identifier, callback = ((node) => node.key)) {
+    delete(identifier, callback = this.defaultOneParamCallback) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
@@ -448,7 +449,7 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `((node: N) => node.key)`, which
+     * `this.defaultOneParamCallback`, which
      * @param [onlyOne=false] - A boolean value indicating whether to stop searching after finding the
      * first node that matches the identifier. If set to true, the function will return an array with
      * only one element (or an empty array if no matching node is found). If set to false (default), the
@@ -460,7 +461,7 @@ class BinaryTree {
      * traverse the binary tree. It can have two possible values:
      * @returns The function `getNodes` returns an array of nodes (`N[]`).
      */
-    getNodes(identifier, callback = ((node) => node.key), onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this.defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         if (identifier instanceof BinaryTreeNode)
@@ -505,7 +506,7 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired criteria. It takes a node as input and returns a boolean value indicating
      * whether the node matches the criteria or not. The default callback function
-     * `((node: N) => node.key)` is used if no callback function is
+     * `this.defaultOneParamCallback` is used if no callback function is
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
      * the node from which the search should begin. By default, it is set to `this.root`, which means the
      * search will start from the root node of the binary tree. However, you can provide a different node
@@ -514,7 +515,7 @@ class BinaryTree {
      * performed when searching for nodes in the binary tree. It can have one of the following values:
      * @returns a boolean value.
      */
-    has(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    has(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
@@ -527,14 +528,14 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired criteria. It takes a node as input and returns a boolean value indicating
      * whether the node matches the criteria or not. The default callback function
-     * (`((node: N) => node.key)`) is used if no callback function is
+     * (`this.defaultOneParamCallback`) is used if no callback function is
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
      * the root node from which the search should begin.
      * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
      * performed when searching for a node in the binary tree. It can have one of the following values:
      * @returns either the found node (of type N) or null if no node is found.
      */
-    getNode(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
@@ -547,14 +548,14 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired criteria. It takes a node as input and returns a boolean value indicating
      * whether the node matches the criteria or not. The default callback function
-     * (`((node: N) => node.key)`) is used if no callback function is
+     * (`this.defaultOneParamCallback`) is used if no callback function is
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
      * the root node from which the search should begin.
      * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
      * performed when searching for a node in the binary tree. It can have one of the following values:
      * @returns either the found value (of type V) or undefined if no node value is found.
      */
-    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
@@ -715,7 +716,7 @@ class BinaryTree {
      * performed on the binary tree. It can have two possible values:
      * @returns The function `subTreeTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
      */
-    subTreeTraverse(callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    subTreeTraverse(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
             beginRoot = this.getNode(beginRoot);
         const ans = [];
@@ -745,7 +746,7 @@ class BinaryTree {
      * function on each node according to a specified order pattern.
      * @param callback - The `callback` parameter is a function that will be called on each node during
      * the depth-first search traversal. It takes a node as input and returns a value. The default value
-     * is `((node: N) => node.key)`, which is a callback function defined elsewhere in the code.
+     * is `this.defaultOneParamCallback`, which is a callback function defined elsewhere in the code.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
      * nodes are visited during the depth-first search. There are three possible values for `pattern`:
      * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the depth-first
@@ -755,7 +756,7 @@ class BinaryTree {
      * iteration used in the depth-first search algorithm. It can have two possible values:
      * @returns The function `dfs` returns an array of `ReturnType<BTNCallback<N>>` values.
      */
-    dfs(callback = ((node) => node.key), pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
+    dfs(callback = this.defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -830,7 +831,7 @@ class BinaryTree {
      * function on each node.
      * @param callback - The `callback` parameter is a function that will be called for each node in the
      * breadth-first search. It takes a node of type `N` as its argument and returns a value of type
-     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `((node: N) => node.key)
+     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this.defaultOneParamCallback
      * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
      * search. It determines from which node the search will begin. If `beginRoot` is `null`, the search
      * will not be performed and an empty array will be returned.
@@ -838,7 +839,7 @@ class BinaryTree {
      * in the breadth-first search (BFS) algorithm. It can have two possible values:
      * @returns The function `bfs` returns an array of `ReturnType<BTNCallback<N>>[]`.
      */
-    bfs(callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    bfs(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -888,7 +889,7 @@ class BinaryTree {
      * level in a binary tree. Each inner array contains the return type of the provided callback
      * function `C` applied to the nodes at that level.
      */
-    listLevels(callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    listLevels(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const levelsNodes = [];
@@ -963,7 +964,7 @@ class BinaryTree {
      * algorithm and returns an array of values obtained by applying a callback function to each node.
      * @param callback - The `callback` parameter is a function that will be called on each node in the
      * tree. It takes a node of type `N` as input and returns a value of type `ReturnType<BTNCallback<N>>`. The
-     * default value for this parameter is `((node: N) => node.key)`.
+     * default value for this parameter is `this.defaultOneParamCallback`.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:
@@ -972,7 +973,7 @@ class BinaryTree {
      * `beginRoot` is `null`, an empty array will be returned.
      * @returns The `morris` function returns an array of `ReturnType<BTNCallback<N>>` values.
      */
-    morris(callback = ((node) => node.key), pattern = 'in', beginRoot = this.root) {
+    morris(callback = this.defaultOneParamCallback, pattern = 'in', beginRoot = this.root) {
         if (beginRoot === null)
             return [];
         const ans = [];

package/dist/{cjs → mjs/src}/data-structures/binary-tree/bst.d.ts

@@ -54,25 +54,6 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns The `addMany` function returns an array of `N`, `null`, or `undefined` values.
      */
     addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: V[], isBalanceAdd?: boolean, iterationType?: IterationType): (N | null | undefined)[];
-    /**
-     * The function returns the first node in the binary tree that matches the given node property and
-     * callback.
-     * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
-     * property of the binary tree node that you want to search for. It can be either a specific key
-     * value (`BTNKey`) or a custom callback function (`BTNCallback<N>`) that determines
-     * whether a node matches the desired property.
-     * @param callback - The `callback` parameter is a function that is used to determine whether a node
-     * matches the desired property. It takes a node as input and returns a boolean value indicating
-     * whether the node matches the property or not. If no callback function is provided, the default
-     * callback function `_defaultCallbackByKey` is used
-     * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
-     * the root node from which the search should begin.
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed when searching for nodes in the binary tree. It can have one of the following values:
-     * @returns either the first node that matches the given nodeProperty and callback, or null if no
-     * matching node is found.
-     */
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
     /**
      * The function `lastKey` returns the key of the rightmost node 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
@@ -97,7 +78,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * generic type `N`.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
-     * included in the result. The default value for `callback` is `((node: N) => node.key)`, which is
+     * included in the result. The default value for `callback` is `this.defaultOneParamCallback`, which is
      * a
      * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
      * the first node that matches the nodeProperty. If set to true, the function will return an array

package/dist/mjs/{data-structures → src/data-structures}/binary-tree/bst.js

@@ -204,27 +204,6 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return inserted;
     }
-    /**
-     * The function returns the first node in the binary tree that matches the given node property and
-     * callback.
-     * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
-     * property of the binary tree node that you want to search for. It can be either a specific key
-     * value (`BTNKey`) or a custom callback function (`BTNCallback<N>`) that determines
-     * whether a node matches the desired property.
-     * @param callback - The `callback` parameter is a function that is used to determine whether a node
-     * matches the desired property. It takes a node as input and returns a boolean value indicating
-     * whether the node matches the property or not. If no callback function is provided, the default
-     * callback function `_defaultCallbackByKey` is used
-     * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
-     * the root node from which the search should begin.
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed when searching for nodes in the binary tree. It can have one of the following values:
-     * @returns either the first node that matches the given nodeProperty and callback, or null if no
-     * matching node is found.
-     */
-    getNode(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
-        return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
-    }
     /**
      * The function `lastKey` returns the key of the rightmost node 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
@@ -256,7 +235,7 @@ class BST extends binary_tree_1.BinaryTree {
      * generic type `N`.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
-     * included in the result. The default value for `callback` is `((node: N) => node.key)`, which is
+     * included in the result. The default value for `callback` is `this.defaultOneParamCallback`, which is
      * a
      * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
      * the first node that matches the nodeProperty. If set to true, the function will return an array
@@ -269,7 +248,7 @@ class BST extends binary_tree_1.BinaryTree {
      * traverse the binary tree. It can have one of the following values:
      * @returns an array of nodes (N[]).
      */
-    getNodes(identifier, callback = ((node) => node.key), onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this.defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -284,7 +263,7 @@ class BST extends binary_tree_1.BinaryTree {
                 if (!cur.left && !cur.right)
                     return;
                 // TODO potential bug
-                if (callback === ((node) => node.key)) {
+                if (callback === this.defaultOneParamCallback) {
                     if (this._compare(cur.key, identifier) === types_1.CP.gt)
                         cur.left && _traverse(cur.left);
                     if (this._compare(cur.key, identifier) === types_1.CP.lt)
@@ -309,7 +288,7 @@ class BST extends binary_tree_1.BinaryTree {
                             return ans;
                     }
                     // TODO potential bug
-                    if (callback === ((node) => node.key)) {
+                    if (callback === this.defaultOneParamCallback) {
                         if (this._compare(cur.key, identifier) === types_1.CP.gt)
                             cur.left && queue.push(cur.left);
                         if (this._compare(cur.key, identifier) === types_1.CP.lt)
@@ -342,7 +321,7 @@ class BST extends binary_tree_1.BinaryTree {
      * done recursively or iteratively. It can have two possible values:
      * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
      */
-    lesserOrGreaterTraverse(callback = ((node) => node.key), lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this.defaultOneParamCallback, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
         if (typeof targetNode === 'number')
             targetNode = this.getNode(targetNode);
         const ans = [];

package/dist/{cjs → mjs/src}/data-structures/binary-tree/tree-multiset.d.ts

@@ -98,7 +98,7 @@ export declare class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = Tr
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `((node: N) => node.key)`
+     * `this.defaultOneParamCallback`
      * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be

package/dist/mjs/{data-structures → src/data-structures}/binary-tree/tree-multiset.js

@@ -252,14 +252,14 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `((node: N) => node.key)`
+     * `this.defaultOneParamCallback`
      * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
      * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    delete(identifier, callback = ((node) => node.key), ignoreCount = false) {
+    delete(identifier, callback = this.defaultOneParamCallback, ignoreCount = false) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;

package/dist/mjs/{data-structures → src/data-structures}/graph/abstract-graph.js

@@ -175,21 +175,21 @@ class AbstractGraph {
             return [];
         }
         const dfs = (cur, dest, visiting, path) => {
-            visiting.set(cur, true);
+            visiting.add(cur);
             if (cur === dest) {
                 paths.push([vertex1, ...path]);
             }
             const neighbors = this.getNeighbors(cur);
             for (const neighbor of neighbors) {
-                if (!visiting.get(neighbor)) {
+                if (!visiting.has(neighbor)) {
                     path.push(neighbor);
                     dfs(neighbor, dest, visiting, path);
-                    (0, utils_1.arrayRemove)(path, (vertex) => vertex === neighbor);
+                    path.pop();
                 }
             }
-            visiting.set(cur, false);
+            visiting.delete(cur);
         };
-        dfs(vertex1, vertex2, new Map(), []);
+        dfs(vertex1, vertex2, new Set(), []);
         return paths;
     }
     /**