data-structure-typed 1.38.4 → 1.38.6

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

@@ -43,7 +43,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
-     * @param {[BinaryTreeNodeKey | N, N['val']][]} arr - The `arr` parameter in the `addMany` function
+     * @param {[BinaryTreeNodeKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BinaryTreeNodeKey` or `N` (which represents the node type in the binary search tree) or
      * `null
@@ -57,7 +57,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
     /**
      * The function returns the first node in the binary tree that matches the given node property and
      * callback.
-     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is used to specify the
+     * @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 (`BinaryTreeNodeKey`) or a custom callback function (`MapCallback<N>`) that determines
      * whether a node matches the desired property.
@@ -72,7 +72,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * @returns either the first node that matches the given nodeProperty and callback, or null if no
      * matching node is found.
      */
-    get<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(nodeProperty: BinaryTreeNodeKey | N, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    get<C extends MapCallback<N>>(identifier: ReturnType<C> | N, 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
@@ -92,7 +92,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
     /**
      * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
      * using either recursive or iterative traversal.
-     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter represents the property
+     * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter represents the property
      * of the binary tree node that you want to search for. It can be either a `BinaryTreeNodeKey` or a
      * generic type `N`.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
@@ -110,7 +110,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * traverse the binary tree. It can have one of the following values:
      * @returns an array of nodes (N[]).
      */
-    getNodes<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(nodeProperty: BinaryTreeNodeKey | N, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
+    getNodes<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     /**
      * The `lesserOrGreaterTraverse` function traverses a binary tree and applies a callback function to
      * nodes that have a key value lesser or greater than a target key value.
@@ -120,7 +120,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It can take one
      * of the following values:
-     * @param {N | BinaryTreeNodeKey | null} targetNode - The `targetNode` parameter in the
+     * @param {BinaryTreeNodeKey | N | null} targetNode - The `targetNode` parameter in the
      * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
      * start. It can be either a reference to a specific node (`N`), the key of a node
      * (`BinaryTreeNodeKey`), or `null` to
@@ -128,7 +128,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * done recursively or iteratively. It can have two possible values:
      * @returns The function `lesserOrGreaterTraverse` returns an array of `MapCallbackReturn<N>`.
      */
-    lesserOrGreaterTraverse<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(callback?: C, lesserOrGreater?: CP, targetNode?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends MapCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BinaryTreeNodeKey | N | null, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Balancing Adjustment:
      * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.

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

@@ -125,7 +125,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
-     * @param {[BinaryTreeNodeKey | N, N['val']][]} arr - The `arr` parameter in the `addMany` function
+     * @param {[BinaryTreeNodeKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BinaryTreeNodeKey` or `N` (which represents the node type in the binary search tree) or
      * `null
@@ -207,7 +207,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function returns the first node in the binary tree that matches the given node property and
      * callback.
-     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is used to specify the
+     * @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 (`BinaryTreeNodeKey`) or a custom callback function (`MapCallback<N>`) that determines
      * whether a node matches the desired property.
@@ -222,8 +222,8 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns either the first node that matches the given nodeProperty and callback, or null if no
      * matching node is found.
      */
-    get(nodeProperty, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
-        return this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0] ?? null;
+    get(identifier, callback = this._defaultCallbackByKey, 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
@@ -251,7 +251,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
      * using either recursive or iterative traversal.
-     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter represents the property
+     * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter represents the property
      * of the binary tree node that you want to search for. It can be either a `BinaryTreeNodeKey` or a
      * generic type `N`.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
@@ -269,14 +269,14 @@ 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(nodeProperty, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const callbackResult = callback(cur);
-                if (callbackResult === nodeProperty) {
+                if (callbackResult === identifier) {
                     ans.push(cur);
                     if (onlyOne)
                         return;
@@ -285,9 +285,9 @@ class BST extends binary_tree_1.BinaryTree {
                     return;
                 // TODO potential bug
                 if (callback === this._defaultCallbackByKey) {
-                    if (this._compare(cur.key, nodeProperty) === types_1.CP.gt)
+                    if (this._compare(cur.key, identifier) === types_1.CP.gt)
                         cur.left && _traverse(cur.left);
-                    if (this._compare(cur.key, nodeProperty) === types_1.CP.lt)
+                    if (this._compare(cur.key, identifier) === types_1.CP.lt)
                         cur.right && _traverse(cur.right);
                 }
                 else {
@@ -303,16 +303,16 @@ class BST extends binary_tree_1.BinaryTree {
                 const cur = queue.shift();
                 if (cur) {
                     const callbackResult = callback(cur);
-                    if (callbackResult === nodeProperty) {
+                    if (callbackResult === identifier) {
                         ans.push(cur);
                         if (onlyOne)
                             return ans;
                     }
                     // TODO potential bug
                     if (callback === this._defaultCallbackByKey) {
-                        if (this._compare(cur.key, nodeProperty) === types_1.CP.gt)
+                        if (this._compare(cur.key, identifier) === types_1.CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.key, nodeProperty) === types_1.CP.lt)
+                        if (this._compare(cur.key, identifier) === types_1.CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -334,7 +334,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It can take one
      * of the following values:
-     * @param {N | BinaryTreeNodeKey | null} targetNode - The `targetNode` parameter in the
+     * @param {BinaryTreeNodeKey | N | null} targetNode - The `targetNode` parameter in the
      * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
      * start. It can be either a reference to a specific node (`N`), the key of a node
      * (`BinaryTreeNodeKey`), or `null` to

package/dist/mjs/data-structures/binary-tree/tree-multiset.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, IterationType } from '../../types';
+import { BinaryTreeDeletedResult, IterationType, MapCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> {
@@ -92,16 +92,20 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     /**
      * The `delete` function in a binary search tree deletes a node from the tree and returns the deleted
      * node along with the parent node that needs to be balanced.
-     * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object
-     * (`N`) or a key value (`BinaryTreeNodeKey`). It represents the node or key that needs to be deleted
-     * from the binary tree.
+     * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
+     * `BinaryTreeNodeKey` or a generic type `N`. It represents the property of the node that we are
+     * searching for. It can be a specific key value or any other property of the node.
+     * @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
+     * `this._defaultCallbackByKey`
      * @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(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    delete<C extends MapCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */

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

@@ -246,20 +246,24 @@ class TreeMultiset extends avl_tree_1.AVLTree {
     /**
      * The `delete` function in a binary search tree deletes a node from the tree and returns the deleted
      * node along with the parent node that needs to be balanced.
-     * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object
-     * (`N`) or a key value (`BinaryTreeNodeKey`). It represents the node or key that needs to be deleted
-     * from the binary tree.
+     * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
+     * `BinaryTreeNodeKey` or a generic type `N`. It represents the property of the node that we are
+     * searching for. It can be a specific key value or any other property of the node.
+     * @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
+     * `this._defaultCallbackByKey`
      * @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(nodeOrKey, ignoreCount = false) {
+    delete(identifier, callback = this._defaultCallbackByKey, ignoreCount = false) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = this.get(nodeOrKey);
+        const curr = this.get(identifier, callback);
         if (!curr)
             return bstDeletedResult;
         const parent = curr?.parent ? curr.parent : null;

package/dist/mjs/data-structures/linked-list/doubly-linked-list.d.ts

@@ -123,7 +123,7 @@ export declare class DoublyLinkedList<E = any> {
      * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
      * is found in the linked list. If no such node is found, it returns `null`.
      */
-    findNode(val: E): DoublyLinkedListNode<E> | null;
+    findNode(val: E | null): DoublyLinkedListNode<E> | null;
     /**
      * The `insert` function inserts a value at a specified index in a doubly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
@@ -229,6 +229,15 @@ export declare class DoublyLinkedList<E = any> {
     reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U;
     insertAfter(existingValueOrNode: E, newValue: E): boolean;
     insertAfter(existingValueOrNode: DoublyLinkedListNode<E>, newValue: E): boolean;
-    insertBefore(existingValueOrNode: E, newValue: E): boolean;
-    insertBefore(existingValueOrNode: DoublyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
+     * list.
+     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion fails.
+     */
+    insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
 }

package/dist/mjs/data-structures/linked-list/singly-linked-list.d.ts

@@ -88,8 +88,14 @@ export declare class SinglyLinkedList<E = any> {
      * bounds.
      */
     deleteAt(index: number): E | undefined;
-    delete(valueOrNode: E): boolean;
-    delete(valueOrNode: SinglyLinkedListNode<E>): boolean;
+    /**
+     * The delete function removes a node with a specific value from a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `E`
+     * or a `SinglyLinkedListNode<E>` object.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the value or node is found and
+     * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
+     */
+    delete(valueOrNode: E | SinglyLinkedListNode<E> | null | undefined): boolean;
     /**
      * The `insertAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
@@ -143,8 +149,15 @@ export declare class SinglyLinkedList<E = any> {
      * the specified value is found, the function returns `null`.
      */
     findNode(value: E): SinglyLinkedListNode<E> | null;
-    insertBefore(existingValue: E, newValue: E): boolean;
-    insertBefore(existingValue: SinglyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
+     * new value before. It can be either the value itself or a node containing the value in the linked list.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
+     * @returns The method `insertBefore` returns a boolean value. It returns `true` if the new value was successfully
+     * inserted before the existing value, and `false` otherwise.
+     */
+    insertBefore(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
     insertAfter(existingValueOrNode: E, newValue: E): boolean;
     insertAfter(existingValueOrNode: SinglyLinkedListNode<E>, newValue: E): boolean;
     /**

package/dist/mjs/data-structures/linked-list/singly-linked-list.js

@@ -207,6 +207,8 @@ class SinglyLinkedList {
      * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
      */
     delete(valueOrNode) {
+        if (!valueOrNode)
+            return false;
         let value;
         if (valueOrNode instanceof SinglyLinkedListNode) {
             value = valueOrNode.val;

package/dist/mjs/interfaces/binary-tree.d.ts

@@ -1,7 +1,7 @@
 import { BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeletedResult, BinaryTreeNodeKey } from '../types';
+import { BinaryTreeDeletedResult, BinaryTreeNodeKey, MapCallback } from '../types';
 export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> {
     createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
-    delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+    delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): BinaryTreeDeletedResult<N>[];
 }

package/dist/mjs/types/helpers.d.ts

@@ -1,6 +1,8 @@
+import { BinaryTreeNodeKey } from './data-structures';
 export type Comparator<T> = (a: T, b: T) => number;
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
 export type MapCallback<N, D = any> = (node: N) => D;
+export type DefaultMapCallback<N, D = BinaryTreeNodeKey> = (node: N) => D;
 export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
 export declare enum CP {
     lt = "lt",