min-heap-typed 1.39.4 → 1.39.5

package/dist/data-structures/graph/undirected-graph.d.ts

@@ -11,7 +11,7 @@ export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
      */
     constructor(key: VertexKey, val?: V);
 }
-export declare class UndirectedEdge<V = number> extends AbstractEdge<V> {
+export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -19,21 +19,21 @@ export declare class UndirectedEdge<V = number> extends AbstractEdge<V> {
      * @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} [val] - The "val" parameter is an optional parameter of type E. It is used to store a value associated
      * with the edge.
      */
-    constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: V);
+    constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: E);
     private _vertices;
     get vertices(): [VertexKey, VertexKey];
     set vertices(v: [VertexKey, VertexKey]);
 }
-export declare class UndirectedGraph<V extends UndirectedVertex<any> = UndirectedVertex, E extends UndirectedEdge<any> = UndirectedEdge> extends AbstractGraph<V, E> implements IGraph<V, E> {
+export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVertex<V> = UndirectedVertex<V>, EO extends UndirectedEdge<E> = UndirectedEdge<E>> extends AbstractGraph<V, E, VO, EO> implements IGraph<V, E, VO, EO> {
     /**
      * The constructor initializes a new Map object to store edges.
      */
     constructor();
-    protected _edges: Map<V, E[]>;
-    get edges(): Map<V, E[]>;
+    protected _edges: Map<VO, EO[]>;
+    get edges(): Map<VO, EO[]>;
     /**
      * 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
@@ -41,9 +41,9 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * @param [val] - The `val` 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: VertexKey, val?: V['val']): V;
+    createVertex(key: VertexKey, val?: VO['val']): VO;
     /**
      * The function creates an undirected edge between two vertices with an optional weight and value.
      * @param {VertexKey} v1 - The parameter `v1` represents the first vertex of the edge.
@@ -52,76 +52,76 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * 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
      * 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: VertexKey, v2: VertexKey, weight?: number, val?: E['val']): E;
+    createEdge(v1: VertexKey, v2: VertexKey, weight?: number, val?: EO['val']): EO;
     /**
      * 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 | null | VertexKey} 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 | null | VertexKey} 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: V | null | VertexKey, v2: V | null | VertexKey): E | null;
+    getEdge(v1: VO | null | VertexKey, v2: VO | null | VertexKey): EO | null;
     /**
      * 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: V | VertexKey, v2: V | VertexKey): E | null;
+    deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | null;
     /**
      * 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: E): E | null;
+    deleteEdge(edge: EO): EO | null;
     /**
      * 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.
      */
-    degreeOf(vertexOrKey: VertexKey | V): number;
+    degreeOf(vertexOrKey: VertexKey | VO): number;
     /**
      * 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: VertexKey | V): E[];
+    edgesOf(vertexOrKey: VertexKey | VO): EO[];
     /**
      * 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(): E[];
+    edgeSet(): EO[];
     /**
      * 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: V | VertexKey): V[];
+    getNeighbors(vertexOrKey: VO | VertexKey): VO[];
     /**
      * 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: E): [V, V] | null;
+    getEndsOfEdge(edge: EO): [VO, VO] | null;
     /**
      * 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.
      */
-    protected _addEdgeOnly(edge: E): boolean;
+    protected _addEdgeOnly(edge: EO): boolean;
     /**
      * 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.
      */
-    protected _setEdges(v: Map<V, E[]>): void;
+    protected _setEdges(v: Map<VO, EO[]>): void;
 }

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

@@ -31,7 +31,7 @@ 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} [val] - The "val" parameter is an optional parameter of type E. It is used to store a value associated
      * with the edge.
      */
     constructor(v1, v2, weight, val) {
@@ -64,7 +64,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * @param [val] - The `val` 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);
@@ -77,18 +77,18 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * 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
      * 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);
     }
     /**
      * 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 | null | VertexKey} 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 | null | VertexKey} 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/queue/queue.d.ts

@@ -4,7 +4,7 @@
  * @class
  */
 import { SinglyLinkedList } from '../linked-list';
-export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
+export declare class SkipQueue<E = any> extends SinglyLinkedList<E> {
     /**
      * The enqueue function adds a value to the end of an array.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.

package/dist/data-structures/queue/queue.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = exports.LinkedListQueue = void 0;
+exports.Queue = exports.SkipQueue = void 0;
 /**
  * @license MIT
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 const linked_list_1 = require("../linked-list");
-class LinkedListQueue extends linked_list_1.SinglyLinkedList {
+class SkipQueue extends linked_list_1.SinglyLinkedList {
     /**
      * The enqueue function adds a value to the end of an array.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
@@ -31,7 +31,7 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
         return (_a = this.head) === null || _a === void 0 ? void 0 : _a.val;
     }
 }
-exports.LinkedListQueue = LinkedListQueue;
+exports.SkipQueue = SkipQueue;
 class Queue {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.

package/dist/interfaces/graph.d.ts

@@ -1,5 +1,5 @@
 import { VertexKey } from '../types';
-export interface IGraph<V, E> {
-    createVertex(key: VertexKey, val?: V): V;
-    createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;
+export interface IGraph<V, E, VO, EO> {
+    createVertex(key: VertexKey, val?: V): VO;
+    createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): EO;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.39.4",
+  "version": "1.39.5",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.39.4"
+    "data-structure-typed": "^1.39.5"
   }
 }