data-structure-typed 1.41.5 → 1.41.6

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;