min-heap-typed 1.39.4 → 1.39.6

package/dist/data-structures/graph/undirected-graph.js

@@ -15,11 +15,11 @@ class UndirectedVertex extends abstract_graph_1.AbstractVertex {
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or network.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(key, val) {
-        super(key, val);
+    constructor(key, value) {
+        super(key, value);
     }
 }
 exports.UndirectedVertex = UndirectedVertex;
@@ -31,11 +31,11 @@ class UndirectedEdge extends abstract_graph_1.AbstractEdge {
      * @param {VertexKey} v2 - The parameter `v2` is a `VertexKey`, which represents the identifier of the second vertex in a
      * graph edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store a value associated
+     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store a value associated
      * with the edge.
      */
-    constructor(v1, v2, weight, val) {
-        super(weight, val);
+    constructor(v1, v2, weight, value) {
+        super(weight, value);
         this._vertices = [v1, v2];
     }
     get vertices() {
@@ -61,13 +61,13 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * The function creates a new vertex with an optional value and returns it.
      * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
      * vertex from another in the graph.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the vertex. If a value is provided,
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the vertex. If a value is provided,
      * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
      * the vertex.
-     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `V`.
+     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `VO`.
      */
-    createVertex(key, val) {
-        return new UndirectedVertex(key, val !== null && val !== void 0 ? val : key);
+    createVertex(key, value) {
+        return new UndirectedVertex(key, value !== null && value !== void 0 ? value : key);
     }
     /**
      * The function creates an undirected edge between two vertices with an optional weight and value.
@@ -75,20 +75,20 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * @param {VertexKey} v2 - The parameter `v2` represents the second vertex of the edge.
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
      * no weight is provided, it defaults to 1.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type and
      * is used to store additional information or data associated with the edge.
-     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `E`.
+     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `EO`.
      */
-    createEdge(v1, v2, weight, val) {
-        return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, val);
+    createEdge(v1, v2, weight, value) {
+        return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, value);
     }
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-     * @param {V | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * @param {VO | VertexKey | null} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
-     * @param {V | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * @param {VO | VertexKey | null} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (vertex ID).
-     * @returns an edge (E) or null.
+     * @returns an edge (EO) or null.
      */
     getEdge(v1, v2) {
         var _a;
@@ -104,10 +104,10 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function removes an edge between two vertices in a graph and returns the removed edge.
-     * @param {V | VertexKey} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexKey`).
-     * @param {V | VertexKey} v2 - V | VertexKey - This parameter can be either a vertex object (V) or a vertex ID
+     * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+     * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
+     * @returns the removed edge (EO) if it exists, or null if either of the vertices (VO) does not exist.
      */
     deleteEdgeBetween(v1, v2) {
         const vertex1 = this._getVertex(v1);
@@ -128,8 +128,8 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The deleteEdge function removes an edge between two vertices in a graph.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The method is returning either the removed edge (of type EO) or null if the edge was not found.
      */
     deleteEdge(edge) {
         return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
@@ -137,7 +137,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     /**
      * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
      * vertex.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
      * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
      * edges connected to that vertex.
      */
@@ -153,8 +153,8 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function returns the edges of a given vertex or vertex ID.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`. A `VertexKey` is a
-     * unique identifier for a vertex in a graph, while `V` represents the type of the vertex.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`. A `VertexKey` is a
+     * unique identifier for a vertex in a graph, while `VO` represents the type of the vertex.
      * @returns an array of edges.
      */
     edgesOf(vertexOrKey) {
@@ -168,7 +168,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function "edgeSet" returns an array of unique edges from a set of edges.
-     * @returns The method `edgeSet()` returns an array of type `E[]`.
+     * @returns The method `edgeSet()` returns an array of type `EO[]`.
      */
     edgeSet() {
         const edgeSet = new Set();
@@ -181,9 +181,9 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
-     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
-     * @returns an array of vertices (V[]).
+     * @returns an array of vertices (VO[]).
      */
     getNeighbors(vertexOrKey) {
         const neighbors = [];
@@ -202,8 +202,8 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     /**
      * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
      * it returns null.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `null`.
      */
     getEndsOfEdge(edge) {
@@ -221,7 +221,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function adds an edge to the graph by updating the adjacency list with the vertices of the edge.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
      * @returns a boolean value.
      */
     _addEdgeOnly(edge) {
@@ -243,7 +243,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function sets the edges of a graph.
-     * @param v - A map where the keys are of type V and the values are arrays of type E.
+     * @param v - A map where the keys are of type VO and the values are arrays of type EO.
      */
     _setEdges(v) {
         this._edges = v;

package/dist/data-structures/hash/hash-table.d.ts

@@ -7,9 +7,9 @@
  */
 export declare class HashTableNode<K, V> {
     key: K;
-    val: V;
+    value: V;
     next: HashTableNode<K, V> | null;
-    constructor(key: K, val: V);
+    constructor(key: K, value: V);
 }
 import { HashFunction } from '../../types';
 export declare class HashTable<K, V> {
@@ -31,12 +31,12 @@ export declare class HashTable<K, V> {
      * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
      * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
      * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
+     * @param {V} value - The parameter `value` represents the value that you want to associate with the given key in the hash
      * table.
      * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
      * value.
      */
-    set(key: K, val: V): void;
+    set(key: K, value: V): void;
     /**
      * The `get` function retrieves the value associated with a given key from a hash table.
      * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data

package/dist/data-structures/hash/hash-table.js

@@ -9,9 +9,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HashTable = exports.HashTableNode = void 0;
 class HashTableNode {
-    constructor(key, val) {
+    constructor(key, value) {
         this.key = key;
-        this.val = val;
+        this.value = value;
         this.next = null;
     }
 }
@@ -48,14 +48,14 @@ class HashTable {
      * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
      * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
      * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
+     * @param {V} value - The parameter `value` represents the value that you want to associate with the given key in the hash
      * table.
      * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
      * value.
      */
-    set(key, val) {
+    set(key, value) {
         const index = this._hash(key);
-        const newNode = new HashTableNode(key, val);
+        const newNode = new HashTableNode(key, value);
         if (!this._buckets[index]) {
             this._buckets[index] = newNode;
         }
@@ -65,7 +65,7 @@ class HashTable {
             while (currentNode) {
                 if (currentNode.key === key) {
                     // If the key already exists, update the value
-                    currentNode.val = val;
+                    currentNode.value = value;
                     return;
                 }
                 if (!currentNode.next) {
@@ -94,7 +94,7 @@ class HashTable {
         let currentNode = this._buckets[index];
         while (currentNode) {
             if (currentNode.key === key) {
-                return currentNode.val;
+                return currentNode.value;
             }
             currentNode = currentNode.next;
         }
@@ -222,7 +222,7 @@ class HashTable {
             let currentNode = bucket;
             while (currentNode) {
                 const newIndex = this._hash(currentNode.key);
-                const newNode = new HashTableNode(currentNode.key, currentNode.val);
+                const newNode = new HashTableNode(currentNode.key, currentNode.value);
                 if (!newBuckets[newIndex]) {
                     newBuckets[newIndex] = newNode;
                 }

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

@@ -8,13 +8,13 @@
 export declare class DoublyLinkedListNode<E = any> {
     /**
      * The constructor function initializes the value, next, and previous properties of an object.
-     * @param {E} val - The "val" parameter is the value that will be stored in the node. It can be of any data type, as it
+     * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
      * is defined as a generic type "E".
      */
-    constructor(val: E);
-    private _val;
-    get val(): E;
-    set val(value: E);
+    constructor(value: E);
+    private _value;
+    get value(): E;
+    set value(value: E);
     private _next;
     get next(): DoublyLinkedListNode<E> | null;
     set next(value: DoublyLinkedListNode<E> | null);
@@ -45,23 +45,23 @@ export declare class DoublyLinkedList<E = any> {
     static fromArray<E>(data: E[]): DoublyLinkedList<E>;
     /**
      * The push function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} val - The value to be added to the linked list.
+     * @param {E} value - The value to be added to the linked list.
      */
-    push(val: E): void;
+    push(value: E): void;
     /**
      * The addLast function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} val - The value to be added to the linked list.
+     * @param {E} value - The value to be added to the linked list.
      */
-    addLast(val: E): void;
+    addLast(value: E): void;
     /**
      * The `pop()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
+     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
      * list is empty, it returns null.
      */
     pop(): E | undefined;
     /**
      * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
+     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
      * list is empty, it returns null.
      */
     popLast(): E | undefined;
@@ -79,16 +79,16 @@ export declare class DoublyLinkedList<E = any> {
     popFirst(): E | undefined;
     /**
      * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} val - The `val` parameter represents the value of the new node that will be added to the beginning of the
+     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
      * doubly linked list.
      */
-    unshift(val: E): void;
+    unshift(value: E): void;
     /**
      * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} val - The `val` parameter represents the value of the new node that will be added to the beginning of the
+     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
      * doubly linked list.
      */
-    addFirst(val: E): void;
+    addFirst(value: E): void;
     /**
      * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty.
      * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
@@ -119,21 +119,21 @@ export declare class DoublyLinkedList<E = any> {
     /**
      * The function `findNodeByValue` searches for a node with a specific value in a doubly linked list and returns the
      * node if found, otherwise it returns null.
-     * @param {E} val - The `val` parameter is the value that we want to search for in the doubly linked list.
-     * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
+     * @param {E} value - The `value` parameter is the value that we want to search for in the doubly linked list.
+     * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `value`
      * is found in the linked list. If no such node is found, it returns `null`.
      */
-    getNode(val: E | null): DoublyLinkedListNode<E> | null;
+    getNode(value: 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
      * DoublyLinkedList. It is of type number.
-     * @param {E} val - The `val` parameter represents the value that you want to insert into the Doubly Linked List at the
+     * @param {E} value - The `value` parameter represents the value that you want to insert into the Doubly Linked List at the
      * specified index.
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insertAt(index: number, val: E): boolean;
+    insertAt(index: number, value: 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
@@ -182,15 +182,15 @@ export declare class DoublyLinkedList<E = any> {
      * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
      * the callback function. If no element satisfies the condition, it returns `null`.
      */
-    find(callback: (val: E) => boolean): E | null;
+    find(callback: (value: E) => boolean): E | null;
     /**
      * The function returns the index of the first occurrence of a given value in a linked list.
-     * @param {E} val - The parameter `val` is of type `E`, which means it can be any data type. It represents the value
+     * @param {E} value - The parameter `value` is of type `E`, which means it can be any data type. It represents the value
      * that we are searching for in the linked list.
-     * @returns The method `indexOf` returns the index of the first occurrence of the specified value `val` in the linked
+     * @returns The method `indexOf` returns the index of the first occurrence of the specified value `value` in the linked
      * list. If the value is not found, it returns -1.
      */
-    indexOf(val: E): number;
+    indexOf(value: E): number;
     /**
      * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
      * value that satisfies the given callback function, or null if no value satisfies the callback.
@@ -199,7 +199,7 @@ export declare class DoublyLinkedList<E = any> {
      * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
      * the callback function. If no value satisfies the condition, it returns `null`.
      */
-    findBackward(callback: (val: E) => boolean): E | null;
+    findBackward(callback: (value: E) => boolean): E | null;
     /**
      * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
      * @returns The `toArrayBackward()` function returns an array of type `E[]`.
@@ -211,11 +211,11 @@ export declare class DoublyLinkedList<E = any> {
     reverse(): void;
     /**
      * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-     * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
+     * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
      * represents the value of the current node in the linked list, and the index argument represents the index of the
      * current node in the linked list.
      */
-    forEach(callback: (val: E, index: number) => void): void;
+    forEach(callback: (value: E, index: number) => void): void;
     /**
      * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
      * DoublyLinkedList with the transformed values.
@@ -224,7 +224,7 @@ export declare class DoublyLinkedList<E = any> {
      * DoublyLinkedList).
      * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
      */
-    map<U>(callback: (val: E) => U): DoublyLinkedList<U>;
+    map<U>(callback: (value: E) => U): DoublyLinkedList<U>;
     /**
      * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
      * elements that satisfy the given callback function.
@@ -232,18 +232,18 @@ export declare class DoublyLinkedList<E = any> {
      * It is used to determine whether a value should be included in the filtered list or not.
      * @returns The filtered list, which is an instance of the DoublyLinkedList class.
      */
-    filter(callback: (val: E) => boolean): DoublyLinkedList<E>;
+    filter(callback: (value: E) => boolean): DoublyLinkedList<E>;
     /**
      * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
      * single value.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
+     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
      * used to perform a specific operation on each element of the linked list.
      * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
      * point for the reduction operation.
      * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
      * elements in the linked list.
      */
-    reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U;
+    reduce<U>(callback: (accumulator: U, value: E) => U, initialValue: U): U;
     /**
      * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
      * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list