data-structure-typed 1.47.7 → 1.47.8

package/dist/mjs/data-structures/graph/abstract-graph.d.ts

@@ -47,13 +47,13 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @param value
      */
     abstract createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
-    abstract deleteEdge(edge: EO): EO | null;
-    abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null;
+    abstract deleteEdge(edge: EO): EO | undefined;
+    abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | undefined;
     abstract degreeOf(vertexOrKey: VO | VertexKey): number;
     abstract edgeSet(): EO[];
     abstract edgesOf(vertexOrKey: VO | VertexKey): EO[];
     abstract getNeighbors(vertexOrKey: VO | VertexKey): VO[];
-    abstract getEndsOfEdge(edge: EO): [VO, VO] | null;
+    abstract getEndsOfEdge(edge: EO): [VO, VO] | undefined;
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -62,13 +62,13 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      *
-     * The function "getVertex" returns the vertex with the specified ID or null if it doesn't exist.
+     * The function "getVertex" returns the vertex with the specified ID or undefined if it doesn't exist.
      * @param {VertexKey} vertexKey - The `vertexKey` parameter is the identifier of the vertex that you want to retrieve from
      * the `_vertices` map.
      * @returns The method `getVertex` returns the vertex with the specified `vertexKey` if it exists in the `_vertices`
-     * map. If the vertex does not exist, it returns `null`.
+     * map. If the vertex does not exist, it returns `undefined`.
      */
-    getVertex(vertexKey: VertexKey): VO | null;
+    getVertex(vertexKey: VertexKey): VO | undefined;
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -201,7 +201,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * vertices. If `isWeight` is `false` or not provided, it uses a breadth-first search (BFS) algorithm to calculate the
      * minimum number of
      */
-    getMinCostBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): number | null;
+    getMinCostBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): number | undefined;
     /**
      * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
@@ -223,9 +223,9 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
      * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
-     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
+     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `undefined`.
      */
-    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS?: boolean): VO[] | null;
+    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS?: boolean): VO[] | undefined;
     /**
      *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
      * /
@@ -242,9 +242,9 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * a graph without using a heap data structure.
      * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
      * vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
      * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
-     * identifier. If no destination is provided, the value is set to `null`.
+     * identifier. If no destination is provided, the value is set to `undefined`.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
      * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
      * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
@@ -253,7 +253,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
+    dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | undefined, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
     /**
      *  Dijkstra algorithm time: O(logVE) space: O(VO + EO)
      *
@@ -276,7 +276,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
      * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
      * start. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
      * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
      * will calculate the shortest paths to all other vertices from the source vertex.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
@@ -287,7 +287,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
+    dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | undefined, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
     /**
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
@@ -353,12 +353,12 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * graph.
      * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
      * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
-     * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+     * `predecessor` property is a 2D array of vertices (or `undefined`) representing the predecessor vertices in the shortest
      * path between vertices in the
      */
     floydWarshall(): {
         costs: number[][];
-        predecessor: (VO | null)[][];
+        predecessor: (VO | undefined)[][];
     };
     /**
      * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
@@ -445,6 +445,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     getBridges(): EO[];
     protected abstract _addEdgeOnly(edge: EO): boolean;
     protected _addVertexOnly(newVertex: VO): boolean;
-    protected _getVertex(vertexOrKey: VertexKey | VO): VO | null;
+    protected _getVertex(vertexOrKey: VertexKey | VO): VO | undefined;
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
 }

package/dist/mjs/data-structures/graph/abstract-graph.js

@@ -58,14 +58,14 @@ export class AbstractGraph {
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      *
-     * The function "getVertex" returns the vertex with the specified ID or null if it doesn't exist.
+     * The function "getVertex" returns the vertex with the specified ID or undefined if it doesn't exist.
      * @param {VertexKey} vertexKey - The `vertexKey` parameter is the identifier of the vertex that you want to retrieve from
      * the `_vertices` map.
      * @returns The method `getVertex` returns the vertex with the specified `vertexKey` if it exists in the `_vertices`
-     * map. If the vertex does not exist, it returns `null`.
+     * map. If the vertex does not exist, it returns `undefined`.
      */
     getVertex(vertexKey) {
-        return this._vertices.get(vertexKey) || null;
+        return this._vertices.get(vertexKey) || undefined;
     }
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
@@ -302,7 +302,7 @@ export class AbstractGraph {
             const vertex2 = this._getVertex(v2);
             const vertex1 = this._getVertex(v1);
             if (!(vertex1 && vertex2)) {
-                return null;
+                return undefined;
             }
             const visited = new Map();
             const queue = new Queue([vertex1]);
@@ -327,7 +327,7 @@ export class AbstractGraph {
                 }
                 cost++;
             }
-            return null;
+            return undefined;
         }
     }
     /**
@@ -351,7 +351,7 @@ export class AbstractGraph {
      * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
      * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
-     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
+     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `undefined`.
      */
     getMinPathBetween(v1, v2, isWeight, isDFS = false) {
         if (isWeight === undefined)
@@ -370,7 +370,7 @@ export class AbstractGraph {
                     }
                     index++;
                 }
-                return allPaths[minIndex] || null;
+                return allPaths[minIndex] || undefined;
             }
             else {
                 return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
@@ -419,9 +419,9 @@ export class AbstractGraph {
      * a graph without using a heap data structure.
      * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
      * vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
      * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
-     * identifier. If no destination is provided, the value is set to `null`.
+     * identifier. If no destination is provided, the value is set to `undefined`.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
      * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
      * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
@@ -436,9 +436,9 @@ export class AbstractGraph {
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
-            dest = null;
+            dest = undefined;
         let minDist = Infinity;
-        let minDest = null;
+        let minDest = undefined;
         let minPath = [];
         const paths = [];
         const vertices = this._vertices;
@@ -446,9 +446,9 @@ export class AbstractGraph {
         const seen = new Set();
         const preMap = new Map(); // predecessor
         const srcVertex = this._getVertex(src);
-        const destVertex = dest ? this._getVertex(dest) : null;
+        const destVertex = dest ? this._getVertex(dest) : undefined;
         if (!srcVertex) {
-            return null;
+            return undefined;
         }
         for (const vertex of vertices) {
             const vertexOrKey = vertex[1];
@@ -456,10 +456,10 @@ export class AbstractGraph {
                 distMap.set(vertexOrKey, Infinity);
         }
         distMap.set(srcVertex, 0);
-        preMap.set(srcVertex, null);
+        preMap.set(srcVertex, undefined);
         const getMinOfNoSeen = () => {
             let min = Infinity;
-            let minV = null;
+            let minV = undefined;
             for (const [key, value] of distMap) {
                 if (!seen.has(key)) {
                     if (value < min) {
@@ -507,7 +507,7 @@ export class AbstractGraph {
                         if (edge) {
                             const curFromMap = distMap.get(cur);
                             const neighborFromMap = distMap.get(neighbor);
-                            // TODO after no-non-null-assertion not ensure the logic
+                            // TODO after no-non-undefined-assertion not ensure the logic
                             if (curFromMap !== undefined && neighborFromMap !== undefined) {
                                 if (edge.weight + curFromMap < neighborFromMap) {
                                     distMap.set(neighbor, edge.weight + curFromMap);
@@ -554,7 +554,7 @@ export class AbstractGraph {
      * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
      * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
      * start. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
      * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
      * will calculate the shortest paths to all other vertices from the source vertex.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
@@ -571,9 +571,9 @@ export class AbstractGraph {
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
-            dest = null;
+            dest = undefined;
         let minDist = Infinity;
-        let minDest = null;
+        let minDest = undefined;
         let minPath = [];
         const paths = [];
         const vertices = this._vertices;
@@ -581,9 +581,9 @@ export class AbstractGraph {
         const seen = new Set();
         const preMap = new Map(); // predecessor
         const srcVertex = this._getVertex(src);
-        const destVertex = dest ? this._getVertex(dest) : null;
+        const destVertex = dest ? this._getVertex(dest) : undefined;
         if (!srcVertex)
-            return null;
+            return undefined;
         for (const vertex of vertices) {
             const vertexOrKey = vertex[1];
             if (vertexOrKey instanceof AbstractVertex)
@@ -592,11 +592,11 @@ export class AbstractGraph {
         const heap = new PriorityQueue([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
-        preMap.set(srcVertex, null);
+        preMap.set(srcVertex, undefined);
         /**
          * The function `getPaths` retrieves all paths from vertices to a specified minimum vertex.
-         * @param {VO | null} minV - The parameter `minV` is of type `VO | null`. It represents the minimum vertex value or
-         * null.
+         * @param {VO | undefined} minV - The parameter `minV` is of type `VO | undefined`. It represents the minimum vertex value or
+         * undefined.
          */
         const getPaths = (minV) => {
             for (const vertex of vertices) {
@@ -732,7 +732,7 @@ export class AbstractGraph {
                 }
             }
         }
-        let minDest = null;
+        let minDest = undefined;
         if (getMin) {
             distMap.forEach((d, v) => {
                 if (v !== srcVertex) {
@@ -808,7 +808,7 @@ export class AbstractGraph {
      * graph.
      * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
      * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
-     * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+     * `predecessor` property is a 2D array of vertices (or `undefined`) representing the predecessor vertices in the shortest
      * path between vertices in the
      */
     floydWarshall() {
@@ -821,7 +821,7 @@ export class AbstractGraph {
             costs[i] = [];
             predecessor[i] = [];
             for (let j = 0; j < n; j++) {
-                predecessor[i][j] = null;
+                predecessor[i][j] = undefined;
             }
         }
         for (let i = 0; i < n; i++) {
@@ -913,7 +913,7 @@ export class AbstractGraph {
                     }
                     const childLow = lowMap.get(neighbor);
                     const curLow = lowMap.get(cur);
-                    // TODO after no-non-null-assertion not ensure the logic
+                    // TODO after no-non-undefined-assertion not ensure the logic
                     if (curLow !== undefined && childLow !== undefined) {
                         lowMap.set(cur, Math.min(curLow, childLow));
                     }
@@ -937,7 +937,7 @@ export class AbstractGraph {
                 }
             }
         };
-        dfs(root, null);
+        dfs(root, undefined);
         let SCCs = new Map();
         const getSCCs = () => {
             const SCCs = new Map();
@@ -1031,7 +1031,7 @@ export class AbstractGraph {
     }
     _getVertex(vertexOrKey) {
         const vertexKey = this._getVertexKey(vertexOrKey);
-        return this._vertices.get(vertexKey) || null;
+        return this._vertices.get(vertexKey) || undefined;
     }
     _getVertexKey(vertexOrKey) {
         return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;

package/dist/mjs/data-structures/graph/directed-graph.d.ts

@@ -74,13 +74,13 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Space Complexity: O(1)
      *
      * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-     * @param {VO | VertexKey | null} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
-     * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `null` if the
+     * @param {VO | VertexKey | undefined} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+     * @param {VO | VertexKey | undefined} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+     * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `undefined` if the
      * destination is not specified.
-     * @returns the first edge found between the source and destination vertices, or null if no such edge is found.
+     * @returns the first edge found between the source and destination vertices, or undefined if no such edge is found.
      */
-    getEdge(srcOrKey: VO | VertexKey | null, destOrKey: VO | VertexKey | null): EO | null;
+    getEdge(srcOrKey: VO | VertexKey | undefined, destOrKey: VO | VertexKey | undefined): EO | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -92,9 +92,9 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * The function removes an edge between two vertices in a graph and returns the removed edge.
      * @param {VO | VertexKey} srcOrKey - The source vertex or its ID.
      * @param {VO | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
-     * @returns the removed edge (EO) if it exists, or null if either the source or destination vertex does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either the source or destination vertex does not exist.
      */
-    deleteEdgeSrcToDest(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null;
+    deleteEdgeSrcToDest(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -103,12 +103,12 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
      *
-     * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
+     * The function removes an edge from a graph and returns the removed edge, or undefined if the edge was not found.
      * @param {EO} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
      * and `dest`, which represent the source and destination vertices of the edge, respectively.
-     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `null` if the edge does not exist.
+     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `undefined` if the edge does not exist.
      */
-    deleteEdge(edge: EO): EO | null;
+    deleteEdge(edge: EO): EO | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -213,11 +213,11 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
+     * The function "getEdgeSrc" returns the source vertex of an edge, or undefined if the edge does not exist.
      * @param {EO} e - The parameter "e" is of type EO, which represents an edge in a graph.
-     * @returns either a vertex object (VO) or null.
+     * @returns either a vertex object (VO) or undefined.
      */
-    getEdgeSrc(e: EO): VO | null;
+    getEdgeSrc(e: EO): VO | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -228,9 +228,9 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      *
      * The function "getEdgeDest" returns the destination vertex of an edge.
      * @param {EO} e - The parameter "e" is of type "EO", which represents an edge in a graph.
-     * @returns either a vertex object of type VO or null.
+     * @returns either a vertex object of type VO or undefined.
      */
-    getEdgeDest(e: EO): VO | null;
+    getEdgeDest(e: EO): VO | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -240,11 +240,11 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Space Complexity: O(1)
      *
      * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
-     * @param {VO | VertexKey | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
-     * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `null`.
+     * @param {VO | VertexKey | undefined} vertex - The `vertex` parameter represents the starting vertex from which we want to
+     * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `undefined`.
      * @returns an array of vertices (VO[]).
      */
-    getDestinations(vertex: VO | VertexKey | null): VO[];
+    getDestinations(vertex: VO | VertexKey | undefined): VO[];
     /**
      * Time Complexity: O(|V| + |E|) where |V| is the number of vertices and |E| is the number of edges
      * Space Complexity: O(|V|)
@@ -254,13 +254,13 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Space Complexity: O(|V|)
      *
      * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
-     * in the sorted order, or null if the graph contains a cycle.
+     * in the sorted order, or undefined if the graph contains a cycle.
      * @param {'vertex' | 'key'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
      * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'key'. If 'vertex' is
      * specified, the vertices themselves will be used for sorting. If 'key' is specified, the ids of
-     * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns null.
+     * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns undefined.
      */
-    topologicalSort(propertyName?: 'vertex' | 'key'): Array<VO | VertexKey> | null;
+    topologicalSort(propertyName?: 'vertex' | 'key'): Array<VO | VertexKey> | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(|E|)
@@ -296,12 +296,12 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Space Complexity: O(1)
      *
      * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it exists in the graph,
-     * otherwise it returns null.
+     * otherwise it returns undefined.
      * @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`.
+     * graph. If the edge does not exist, it returns `undefined`.
      */
-    getEndsOfEdge(edge: EO): [VO, VO] | null;
+    getEndsOfEdge(edge: EO): [VO, VO] | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/mjs/data-structures/graph/directed-graph.js

@@ -96,15 +96,15 @@ export class DirectedGraph extends AbstractGraph {
      * Space Complexity: O(1)
      *
      * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-     * @param {VO | VertexKey | null} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
-     * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `null` if the
+     * @param {VO | VertexKey | undefined} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+     * @param {VO | VertexKey | undefined} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+     * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `undefined` if the
      * destination is not specified.
-     * @returns the first edge found between the source and destination vertices, or null if no such edge is found.
+     * @returns the first edge found between the source and destination vertices, or undefined if no such edge is found.
      */
     getEdge(srcOrKey, destOrKey) {
         let edges = [];
-        if (srcOrKey !== null && destOrKey !== null) {
+        if (srcOrKey !== undefined && destOrKey !== undefined) {
             const src = this._getVertex(srcOrKey);
             const dest = this._getVertex(destOrKey);
             if (src && dest) {
@@ -114,7 +114,7 @@ export class DirectedGraph extends AbstractGraph {
                 }
             }
         }
-        return edges[0] || null;
+        return edges[0] || undefined;
     }
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
@@ -127,14 +127,14 @@ export class DirectedGraph extends AbstractGraph {
      * The function removes an edge between two vertices in a graph and returns the removed edge.
      * @param {VO | VertexKey} srcOrKey - The source vertex or its ID.
      * @param {VO | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
-     * @returns the removed edge (EO) if it exists, or null if either the source or destination vertex does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either the source or destination vertex does not exist.
      */
     deleteEdgeSrcToDest(srcOrKey, destOrKey) {
         const src = this._getVertex(srcOrKey);
         const dest = this._getVertex(destOrKey);
-        let removed = null;
+        let removed = undefined;
         if (!src || !dest) {
-            return null;
+            return undefined;
         }
         const srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges) {
@@ -142,7 +142,7 @@ export class DirectedGraph extends AbstractGraph {
         }
         const destInEdges = this._inEdgeMap.get(dest);
         if (destInEdges) {
-            removed = arrayRemove(destInEdges, (edge) => edge.src === src.key)[0] || null;
+            removed = arrayRemove(destInEdges, (edge) => edge.src === src.key)[0] || undefined;
         }
         return removed;
     }
@@ -154,13 +154,13 @@ export class DirectedGraph extends AbstractGraph {
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
      *
-     * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
+     * The function removes an edge from a graph and returns the removed edge, or undefined if the edge was not found.
      * @param {EO} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
      * and `dest`, which represent the source and destination vertices of the edge, respectively.
-     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `null` if the edge does not exist.
+     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `undefined` if the edge does not exist.
      */
     deleteEdge(edge) {
-        let removed = null;
+        let removed = undefined;
         const src = this._getVertex(edge.src);
         const dest = this._getVertex(edge.dest);
         if (src && dest) {
@@ -308,9 +308,9 @@ export class DirectedGraph extends AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
+     * The function "getEdgeSrc" returns the source vertex of an edge, or undefined if the edge does not exist.
      * @param {EO} e - The parameter "e" is of type EO, which represents an edge in a graph.
-     * @returns either a vertex object (VO) or null.
+     * @returns either a vertex object (VO) or undefined.
      */
     getEdgeSrc(e) {
         return this._getVertex(e.src);
@@ -325,7 +325,7 @@ export class DirectedGraph extends AbstractGraph {
      *
      * The function "getEdgeDest" returns the destination vertex of an edge.
      * @param {EO} e - The parameter "e" is of type "EO", which represents an edge in a graph.
-     * @returns either a vertex object of type VO or null.
+     * @returns either a vertex object of type VO or undefined.
      */
     getEdgeDest(e) {
         return this._getVertex(e.dest);
@@ -339,12 +339,12 @@ export class DirectedGraph extends AbstractGraph {
      * Space Complexity: O(1)
      *
      * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
-     * @param {VO | VertexKey | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
-     * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `null`.
+     * @param {VO | VertexKey | undefined} vertex - The `vertex` parameter represents the starting vertex from which we want to
+     * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `undefined`.
      * @returns an array of vertices (VO[]).
      */
     getDestinations(vertex) {
-        if (vertex === null) {
+        if (vertex === undefined) {
             return [];
         }
         const destinations = [];
@@ -366,11 +366,11 @@ export class DirectedGraph extends AbstractGraph {
      * Space Complexity: O(|V|)
      *
      * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
-     * in the sorted order, or null if the graph contains a cycle.
+     * in the sorted order, or undefined if the graph contains a cycle.
      * @param {'vertex' | 'key'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
      * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'key'. If 'vertex' is
      * specified, the vertices themselves will be used for sorting. If 'key' is specified, the ids of
-     * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns null.
+     * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns undefined.
      */
     topologicalSort(propertyName) {
         propertyName = propertyName ?? 'key';
@@ -403,7 +403,7 @@ export class DirectedGraph extends AbstractGraph {
             }
         }
         if (hasCycle)
-            return null;
+            return undefined;
         if (propertyName === 'key')
             sorted = sorted.map(vertex => (vertex instanceof DirectedVertex ? vertex.key : vertex));
         return sorted.reverse();
@@ -446,7 +446,7 @@ export class DirectedGraph extends AbstractGraph {
             const outEdges = this.outgoingEdgesOf(vertex);
             for (const outEdge of outEdges) {
                 const neighbor = this._getVertex(outEdge.dest);
-                // TODO after no-non-null-assertion not ensure the logic
+                // TODO after no-non-undefined-assertion not ensure the logic
                 if (neighbor) {
                     neighbors.push(neighbor);
                 }
@@ -463,14 +463,14 @@ export class DirectedGraph extends AbstractGraph {
      * Space Complexity: O(1)
      *
      * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it exists in the graph,
-     * otherwise it returns null.
+     * otherwise it returns undefined.
      * @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`.
+     * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge) {
         if (!this.hasEdge(edge.src, edge.dest)) {
-            return null;
+            return undefined;
         }
         const v1 = this._getVertex(edge.src);
         const v2 = this._getVertex(edge.dest);
@@ -478,7 +478,7 @@ export class DirectedGraph extends AbstractGraph {
             return [v1, v2];
         }
         else {
-            return null;
+            return undefined;
         }
     }
     /**
@@ -501,7 +501,7 @@ export class DirectedGraph extends AbstractGraph {
         }
         const srcVertex = this._getVertex(edge.src);
         const destVertex = this._getVertex(edge.dest);
-        // TODO after no-non-null-assertion not ensure the logic
+        // TODO after no-non-undefined-assertion not ensure the logic
         if (srcVertex && destVertex) {
             const srcOutEdges = this._outEdgeMap.get(srcVertex);
             if (srcOutEdges) {