min-heap-typed 1.38.4 → 1.38.5

package/dist/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/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/data-structures/linked-list/singly-linked-list.js

@@ -202,6 +202,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.38.4",
+  "version": "1.38.5",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -266,7 +266,7 @@ export 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 {
     let current = this.head;
 
     while (current) {
@@ -341,7 +341,7 @@ export class DoublyLinkedList<E = any> {
    * @returns The `delete` method returns a boolean value. It returns `true` if the value or node was successfully
    * deleted from the doubly linked list, and `false` if the value or node was not found in the list.
    */
-  delete(valOrNode: E | DoublyLinkedListNode<E>): boolean {
+  delete(valOrNode: E | DoublyLinkedListNode<E> | null): boolean {
     let node: DoublyLinkedListNode<E> | null;
 
     if (valOrNode instanceof DoublyLinkedListNode) {
@@ -594,8 +594,6 @@ export class DoublyLinkedList<E = any> {
     return false;
   }
 
-  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.

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -214,9 +214,6 @@ export class SinglyLinkedList<E = any> {
     return removedNode!.val;
   }
 
-  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`
@@ -224,7 +221,8 @@ export class SinglyLinkedList<E = any> {
    * @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>): boolean {
+  delete(valueOrNode: E | SinglyLinkedListNode<E> | null | undefined): boolean {
+    if (!valueOrNode) return false;
     let value: E;
     if (valueOrNode instanceof SinglyLinkedListNode) {
       value = valueOrNode.val;
@@ -397,9 +395,6 @@ export class SinglyLinkedList<E = any> {
     return 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