data-structure-typed 0.8.18 → 1.12.9

package/src/data-structures/graph/directed-graph.ts

@@ -1,5 +1,10 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import {arrayRemove} from '../../utils';
-import {AbstractEdge, AbstractGraph, AbstractVertex, VertexId} from './abstract-graph';
+import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
+import type {IDirectedGraph, TopologicalStatus, VertexId} from '../types';
 
 export class DirectedVertex extends AbstractVertex {
     constructor(id: VertexId) {
@@ -34,25 +39,8 @@ export class DirectedEdge extends AbstractEdge {
     }
 }
 
-export interface I_DirectedGraph<V, E> {
-    incomingEdgesOf(vertex: V): E[];
-
-    outgoingEdgesOf(vertex: V): E[];
-
-    inDegreeOf(vertexOrId: V | VertexId): number;
-
-    outDegreeOf(vertexOrId: V | VertexId): number;
-
-    getEdgeSrc(e: E): V | null;
-
-    getEdgeDest(e: E): V | null;
-}
-
-// 0 means unknown, 1 means visiting, 2 means visited;
-export type TopologicalStatus = 0 | 1 | 2;
-
 // Strongly connected, One direction connected, Weakly connected
-export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements I_DirectedGraph<V, E> {
+export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
 
     protected _outEdgeMap: Map<V, E[]> = new Map<V, E[]>();
 
@@ -62,6 +50,14 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         super();
     }
 
+    /**
+     * The function `getEdge` returns the first edge between two vertices, given their source and destination.
+     * @param {V | null | VertexId} srcOrId - The `srcOrId` parameter can be either a vertex object (`V`), a vertex ID
+     * (`VertexId`), or `null`. It represents the source vertex of the edge.
+     * @param {V | null | VertexId} destOrId - The `destOrId` parameter is either a vertex object (`V`), a vertex ID
+     * (`VertexId`), or `null`. It represents the destination vertex of the edge.
+     * @returns an edge (E) or null.
+     */
     getEdge(srcOrId: V | null | VertexId, destOrId: V | null | VertexId): E | null {
         let edges: E[] = [];
 
@@ -80,6 +76,13 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         return edges[0] || null;
     }
 
+    /**
+     * The `addEdge` function adds an edge to a graph if the source and destination vertices exist.
+     * @param {E} edge - The parameter `edge` is of type `E`, which represents an edge in the graph. It contains
+     * information about the source vertex (`src`) and the destination vertex (`dest`) of the edge.
+     * @returns The `addEdge` function returns a boolean value. It returns `true` if the edge was successfully added to the
+     * graph, and `false` if either the source or destination vertices of the edge are not present in the graph.
+     */
     addEdge(edge: E): boolean {
         if (!(this.containsVertex(edge.src) && this.containsVertex(edge.dest))) {
             return false;
@@ -109,6 +112,16 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         }
     }
 
+    /**
+     * The function removes an edge between two vertices in a directed graph and returns the removed edge.
+     * @param {V | VertexId} srcOrId - The source vertex or its ID.
+     * @param {V | VertexId} destOrId - The `destOrId` parameter in the `removeEdgeBetween` function represents the
+     * destination vertex of the edge that needs to be removed. It can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The function `removeEdgeBetween` returns the removed edge (`E`) if the edge between the source and
+     * destination vertices is successfully removed. If either the source or destination vertex is not found, or if the
+     * edge does not exist, it returns `null`.
+     */
     removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null {
 
         const src: V | null = this.getVertex(srcOrId);
@@ -120,29 +133,44 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
 
         const srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges) {
-            arrayRemove<E>(srcOutEdges, edge => edge.dest === dest.id);
+    /**
+     * The removeEdge function removes an edge from a graph and returns the removed edge, or null if the edge was not
+     * found.
+     * @param {E} edge - The `edge` parameter represents the edge that you want to remove from the graph. It should be an
+     * object that has `src` and `dest` properties, which represent the source and destination vertices of the edge,
+     * respectively.
+     * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+     */
+            arrayRemove<E>(srcOutEdges, (edge: DirectedEdge) => edge.dest === dest.id);
         }
 
         const destInEdges = this._inEdgeMap.get(dest);
         if (destInEdges) {
-            removed = arrayRemove<E>(destInEdges, edge => edge.src === src.id)[0] || null;
+            removed = arrayRemove<E>(destInEdges, (edge: DirectedEdge) => edge.src === src.id)[0] || null;
         }
         return removed;
     }
 
-    removeEdge(edge: E): E | null {
+    /**
+     * The removeEdge function removes an edge from a graph and returns the removed edge, or null if the edge was not
+     * found.
+     * @param {E} 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 `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+     */
+    removeEdge(edge: E ): E | null {
         let removed: E | null = null;
         const src = this.getVertex(edge.src);
         const dest = this.getVertex(edge.dest);
         if (src && dest) {
             const srcOutEdges = this._outEdgeMap.get(src);
             if (srcOutEdges && srcOutEdges.length > 0) {
-                arrayRemove(srcOutEdges, edge => edge.src === src.id);
+                arrayRemove(srcOutEdges, (edge: DirectedEdge) => edge.src === src.id);
             }
 
             const destInEdges = this._inEdgeMap.get(dest);
             if (destInEdges && destInEdges.length > 0) {
-                removed = arrayRemove(destInEdges, edge => edge.dest === dest.id)[0];
+                removed = arrayRemove(destInEdges, (edge: DirectedEdge) => edge.dest === dest.id)[0];
             }
 
         }
@@ -150,10 +178,24 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         return removed;
     }
 
+    /**
+     * The function removeAllEdges removes all edges between two vertices.
+     * @param {VertexId | V} src - The `src` parameter represents the source vertex from which the edges will be removed.
+     * It can be either a `VertexId` or a `V` type, which represents the identifier or object of the vertex.
+     * @param {VertexId | V} dest - The `dest` parameter represents the destination vertex of an edge. It can be either a
+     * `VertexId` or a vertex object `V`.
+     * @returns An empty array is being returned.
+     */
     removeAllEdges(src: VertexId | V, dest: VertexId | V): E[] {
         return [];
     }
 
+    /**
+     * The function `incomingEdgesOf` returns an array of incoming edges for a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `incomingEdgesOf` returns an array of edges (`E[]`).
+     */
     incomingEdgesOf(vertexOrId: V | VertexId): E[] {
         const target = this.getVertex(vertexOrId);
         if (target) {
@@ -162,6 +204,12 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         return [];
     }
 
+    /**
+     * The function `outgoingEdgesOf` returns an array of outgoing edges from a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `outgoingEdgesOf` returns an array of outgoing edges from a given vertex or vertex ID.
+     */
     outgoingEdgesOf(vertexOrId: V | VertexId): E[] {
         const target = this.getVertex(vertexOrId);
         if (target) {
@@ -170,31 +218,68 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         return [];
     }
 
+    /**
+     * The function "degreeOf" returns the total degree of a vertex, which is the sum of its out-degree and in-degree.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns the sum of the out-degree and in-degree of the specified vertex or vertex ID.
+     */
     degreeOf(vertexOrId: VertexId | V): number {
         return this.outDegreeOf(vertexOrId) + this.inDegreeOf(vertexOrId);
     }
 
+    /**
+     * The function "inDegreeOf" returns the number of incoming edges for a given vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The number of incoming edges of the specified vertex or vertex ID.
+     */
     inDegreeOf(vertexOrId: VertexId | V): number {
         return this.incomingEdgesOf(vertexOrId).length;
     }
 
+    /**
+     * The function `outDegreeOf` returns the number of outgoing edges from a given vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The number of outgoing edges from the specified vertex or vertex ID.
+     */
     outDegreeOf(vertexOrId: VertexId | V): number {
         return this.outgoingEdgesOf(vertexOrId).length;
     }
 
+    /**
+     * The function "edgesOf" returns an array of both outgoing and incoming edges of a given vertex or vertex ID.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The function `edgesOf` returns an array of edges.
+     */
     edgesOf(vertexOrId: VertexId | V): E[] {
         return [...this.outgoingEdgesOf(vertexOrId), ...this.incomingEdgesOf(vertexOrId)];
     }
 
+    /**
+     * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
+     * @param {E} e - E - an edge object
+     * @returns the source vertex of the given edge, or null if the edge does not exist.
+     */
     getEdgeSrc(e: E): V | null {
         return this.getVertex(e.src);
     }
 
+    /**
+     * The function "getEdgeDest" returns the vertex associated with the destination of an edge.
+     * @param {E} e - The parameter `e` is of type `E`, which represents an edge in a graph.
+     * @returns either a vertex object (of type V) or null.
+     */
     getEdgeDest(e: E): V | null {
         return this.getVertex(e.dest);
     }
 
-    getDestinations(vertex: V | null): V[] {
+    /**
+     * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
+     * @param {V | VertexId | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
+     * find the destinations. It can be either a `V` object, a `VertexId` (which is a unique identifier for a vertex), or
+     * `null` if we want to find destinations from all vertices.
+     * @returns an array of vertices (V[]).
+     */
+    getDestinations(vertex: V | VertexId | null): V[] {
         if (vertex === null) {
             return [];
         }
@@ -214,6 +299,10 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
     /**
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
+     * The `topologicalSort` function performs a topological sort on a directed graph and returns the sorted vertices in
+     * reverse order, or null if the graph contains a cycle.
+     * @returns The function `topologicalSort()` returns an array of vertices in topological order if there is no cycle in
+     * the graph. If there is a cycle in the graph, it returns `null`.
      */
     topologicalSort(): V[] | null {
         // vector<vector<int>> g;
@@ -252,7 +341,7 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
             statusMap.set(entry[1], 0);
         }
 
-        const sorted: V[] = [];
+        const sorted: (V)[] = [];
         let hasCycle = false;
         const dfs = (cur: V) => {
             statusMap.set(cur, 1);
@@ -283,6 +372,10 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
 
     /**--- end find cycles --- */
 
+    /**
+     * The `edgeSet` function returns an array of all the edges in the graph.
+     * @returns The `edgeSet()` method returns an array of edges (`E[]`).
+     */
     edgeSet(): E[] {
         let edges: E[] = [];
         this._outEdgeMap.forEach(outEdges => {
@@ -291,6 +384,12 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         return edges;
     }
 
+    /**
+     * The function `getNeighbors` returns an array of neighboring vertices for a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns an array of vertices (V[]).
+     */
     getNeighbors(vertexOrId: V | VertexId): V[] {
         const neighbors: V[] = [];
         const vertex = this.getVertex(vertexOrId);
@@ -307,6 +406,13 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         return neighbors;
     }
 
+    /**
+     * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it 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 an array containing two vertices [V, V] if the edge is found in the graph. If the edge is not found, it
+     * returns null.
+     */
     getEndsOfEdge(edge: E): [V, V] | null {
         if (!this.containsEdge(edge.src, edge.dest)) {
             return null;

package/src/data-structures/graph/undirected-graph.ts

@@ -1,5 +1,10 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import {arrayRemove} from '../../utils';
-import {AbstractEdge, AbstractGraph, AbstractVertex, VertexId} from './abstract-graph';
+import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
+import type {VertexId} from '../types';
 
 export class UndirectedVertex extends AbstractVertex {
     constructor(id: VertexId) {
@@ -8,6 +13,11 @@ export class UndirectedVertex extends AbstractVertex {
 }
 
 export class UndirectedEdge extends AbstractEdge {
+    constructor(v1: VertexId, v2: VertexId, weight?: number) {
+        super(weight);
+        this._vertices = [v1, v2];
+    }
+
     private _vertices: [VertexId, VertexId];
 
     public get vertices() {
@@ -17,20 +27,23 @@ export class UndirectedEdge extends AbstractEdge {
     public set vertices(v: [VertexId, VertexId]) {
         this._vertices = v;
     }
-
-    constructor(v1: VertexId, v2: VertexId, weight?: number) {
-        super(weight);
-        this._vertices = [v1, v2];
-    }
 }
 
 export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
+    protected _edges: Map<V, E[]> = new Map();
+
     constructor() {
         super();
     }
 
-    protected _edges: Map<V, E[]> = new Map();
-
+    /**
+     * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
+     * @param {V | null | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID
+     * (`VertexId`). It can also be `null`.
+     * @param {V | null | VertexId} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * object), `null`, or `VertexId` (vertex ID).
+     * @returns an edge (E) or null.
+     */
     getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null {
         let edges: E[] | undefined = [];
 
@@ -46,6 +59,11 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return edges ? edges[0] || null : null;
     }
 
+    /**
+     * The function adds an edge to a graph by connecting two vertices.
+     * @param {E} edge - The `edge` parameter is an object of type `E`, which represents an edge in a graph.
+     * @returns a boolean value.
+     */
     addEdge(edge: E): boolean {
         for (const end of edge.vertices) {
             const endVertex = this.getVertex(end);
@@ -62,6 +80,13 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return true;
     }
 
+    /**
+     * The function removes an edge between two vertices in a graph and returns the removed edge, or null if either of the
+     * vertices does not exist.
+     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
+     * @param {V | VertexId} v2 - V | VertexId: The second vertex or vertex ID of the edge to be removed.
+     * @returns the removed edge (E) if it exists, or null if either of the vertices (v1 or v2) does not exist.
+     */
     removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null {
 
         const vertex1: V | null = this.getVertex(v1);
@@ -74,20 +99,31 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         const v1Edges = this._edges.get(vertex1);
         let removed: E | null = null;
         if (v1Edges) {
-            removed = arrayRemove<E>(v1Edges, e => e.vertices.includes(vertex2.id))[0] || null;
+            removed = arrayRemove<E>(v1Edges, (e: UndirectedEdge) => e.vertices.includes(vertex2.id))[0] || null;
         }
         const v2Edges = this._edges.get(vertex2);
         if (v2Edges) {
-            arrayRemove<E>(v2Edges, e => e.vertices.includes(vertex1.id));
+            arrayRemove<E>(v2Edges, (e: UndirectedEdge) => e.vertices.includes(vertex1.id));
         }
         return removed;
     }
 
-
+    /**
+     * The removeEdge 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.
+     */
     removeEdge(edge: E): E | null {
         return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
     }
 
+    /**
+     * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
+     * vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
+     * edges that are incident to that vertex.
+     */
     degreeOf(vertexOrId: VertexId | V): number {
         const vertex = this.getVertex(vertexOrId);
         if (vertex) {
@@ -97,6 +133,13 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         }
     }
 
+    /**
+     * The function "edgesOf" returns an array of edges connected to a given vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns an array of edges connected to the specified vertex. If the vertex exists in the graph, the function
+     * returns the array of edges connected to that vertex. If the vertex does not exist in the graph, the function returns
+     * an empty array.
+     */
     edgesOf(vertexOrId: VertexId | V): E[] {
         const vertex = this.getVertex(vertexOrId);
         if (vertex) {
@@ -106,6 +149,10 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         }
     }
 
+    /**
+     * The function "edgeSet" returns an array of unique edges from a set of edges.
+     * @returns The method `edgeSet()` returns an array of type `E[]`.
+     */
     edgeSet(): E[] {
         const edgeSet: Set<E> = new Set();
         this._edges.forEach(edges => {
@@ -116,6 +163,12 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return [...edgeSet];
     }
 
+    /**
+     * The function "getEdgesOf" returns an array of edges connected to a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns an array of edges (E[]) that are connected to the specified vertex or vertex ID.
+     */
     getEdgesOf(vertexOrId: V | VertexId): E[] {
         const vertex = this.getVertex(vertexOrId);
         if (!vertex) {
@@ -124,6 +177,12 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return this._edges.get(vertex) || [];
     }
 
+    /**
+     * The function "getNeighbors" returns an array of neighboring vertices of a given vertex.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns an array of vertices (V[]).
+     */
     getNeighbors(vertexOrId: V | VertexId): V[] {
         const neighbors: V[] = [];
         const vertex = this.getVertex(vertexOrId);
@@ -139,6 +198,14 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         return neighbors;
     }
 
+    /**
+     * The function "getEndsOfEdge" returns the vertices at the ends of a given edge, or null if the edge does not exist in
+     * the graph.
+     * @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
+     * graph and both vertices are found. If the edge does not exist or one or both vertices are not found, it returns
+     * `null`.
+     */
     getEndsOfEdge(edge: E): [V, V] | null {
         if (!this.containsEdge(edge.vertices[0], edge.vertices[1])) {
             return null;

package/src/data-structures/hash/coordinate-map.ts

@@ -1,4 +1,8 @@
-export class CoordinateSet<V> extends Map<any, V> {
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+export class CoordinateMap<V> extends Map<any, V> {
     private readonly _joint: string = '_';
 
     constructor(joint?: string) {
@@ -6,18 +10,46 @@ export class CoordinateSet<V> extends Map<any, V> {
         if (joint !== undefined) this._joint = joint;
     }
 
+    /**
+     * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
+     * key array with a specified delimiter.
+     * @param {number[]} key - The parameter "key" is an array of numbers.
+     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
+     * (`super.has`) with the `key` array joined together using the `_joint` property.
+     */
     override has(key: number[]) {
         return super.has(key.join(this._joint));
     }
 
+    /**
+     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
+     * delimiter before calling the original set method.
+     * @param {number[]} key - The key parameter is an array of numbers.
+     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
+     * @returns The `set` method is returning the result of calling the `set` method of the superclass
+     * (`super.set(key.join(this._joint), value)`).
+     */
     override set(key: number[], value: V) {
         return super.set(key.join(this._joint), value);
     }
 
+    /**
+     * The function overrides the get method to join the key array with a specified joint and then calls the super get
+     * method.
+     * @param {number[]} key - An array of numbers
+     * @returns The code is returning the value associated with the specified key in the map.
+     */
     override get(key: number[]) {
         return super.get(key.join(this._joint));
     }
 
+    /**
+     * The function overrides the delete method and joins the key array using a specified joint character before calling
+     * the super delete method.
+     * @param {number[]} key - An array of numbers that represents the key to be deleted.
+     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
+     * `key` array joined together using the `_joint` property.
+     */
     override delete(key: number[]) {
         return super.delete(key.join(this._joint));
     }

package/src/data-structures/hash/coordinate-set.ts

@@ -1,3 +1,7 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 export class CoordinateSet extends Set {
     private readonly _joint: string = '_';
 
@@ -6,14 +10,35 @@ export class CoordinateSet extends Set {
         if (joint !== undefined) this._joint = joint;
     }
 
+    /**
+     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
+     * joining its elements with a specified separator.
+     * @param {number[]} value - The parameter "value" is an array of numbers.
+     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
+     * in the joined value as an argument.
+     */
     override has(value: number[]) {
         return super.has(value.join(this._joint));
     }
 
+    /**
+     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
+     * specified delimiter before calling the parent class's "add" function.
+     * @param {number[]} value - An array of numbers
+     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
+     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
+     */
     override add(value: number[]) {
         return super.add(value.join(this._joint));
     }
 
+    /**
+     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
+     * array with a specified joint and then calling the delete method of the parent class.
+     * @param {number[]} value - An array of numbers
+     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
+     * `value` array joined together using the `_joint` property.
+     */
     override delete(value: number[]) {
         return super.delete(value.join(this._joint));
     }

package/src/data-structures/hash/index.ts

@@ -1 +1,6 @@
 export * from './hash-table';
+export * from './coordinate-map';
+export * from './coordinate-set';
+export * from './pair';
+export * from './tree-map';
+export * from './tree-set';