data-structure-typed 1.12.9 → 1.12.11

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

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import {arrayRemove, uuidV4} from '../../utils';
 import {PriorityQueue} from '../priority-queue';
@@ -26,6 +29,11 @@ export abstract class AbstractEdge {
 
     static DEFAULT_EDGE_WEIGHT = 1;
 
+    /**
+     * The function is a protected constructor that initializes the weight and generates a unique hash code for an edge.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
+     * no weight is provided, it will default to the value of `AbstractEdge.DEFAULT_EDGE_WEIGHT`.
+     */
     protected constructor(weight?: number) {
         if (weight === undefined) weight = AbstractEdge.DEFAULT_EDGE_WEIGHT;
         this._weight = weight;
@@ -535,7 +543,7 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
         }
 
         const heap = new PriorityQueue<{ id: number, val: V }>({comparator: (a, b) => a.id - b.id});
-        heap.offer({id: 0, val: srcVertex});
+        heap.add({id: 0, val: srcVertex});
 
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
@@ -582,7 +590,7 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
                                 const distSrcToNeighbor = distMap.get(neighbor);
                                 if (distSrcToNeighbor) {
                                     if (dist + weight < distSrcToNeighbor) {
-                                        heap.offer({id: dist + weight, val: neighbor});
+                                        heap.add({id: dist + weight, val: neighbor});
                                         preMap.set(neighbor, cur);
                                         distMap.set(neighbor, dist + weight);
                                     }

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

@@ -1,18 +1,35 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import {arrayRemove} from '../../utils';
 import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
 import type {IDirectedGraph, TopologicalStatus, VertexId} from '../types';
 
 export class DirectedVertex extends AbstractVertex {
+    /**
+     * The constructor function initializes an object with a given id.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
+     * vertex within a graph or network.
+     */
     constructor(id: VertexId) {
         super(id);
     }
 }
 
 export class DirectedEdge extends AbstractEdge {
+    /**
+     * The constructor function initializes the source and destination vertices of an edge, with an optional weight.
+     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * a graph.
+     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex. It represents the vertex
+     * to which an edge is directed.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
+     * between two vertices.
+     */
     constructor(src: VertexId, dest: VertexId, weight?: number) {
         super(weight);
         this._src = src;
@@ -170,7 +187,7 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
 
             const destInEdges = this._inEdgeMap.get(dest);
             if (destInEdges && destInEdges.length > 0) {
-                removed = arrayRemove(destInEdges, (edge: DirectedEdge) => edge.dest === dest.id)[0];
+                removed = arrayRemove(destInEdges, (edge: E) => edge.dest === dest.id)[0];
             }
 
         }
@@ -299,41 +316,12 @@ 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`.
+     * The `topologicalSort` function performs a topological sort on a graph and returns the sorted vertices in reverse
+     * order, or null if the graph contains a cycle.
+     * @returns The `topologicalSort()` function returns an array of vertices (`V[]`) in topological order if there is no
+     * cycle in the graph. If there is a cycle, it returns `null`.
      */
     topologicalSort(): V[] | null {
-        // vector<vector<int>> g;
-        // vector<int> color;
-        // int last;
-        // bool hasCycle;
-        //
-        // bool topo_sort() {
-        //     int n = g.size();
-        //     vector<int> degree(n, 0);
-        //     queue<int> q;
-        //     for (int i = 0; i < n; i++) {
-        //         degree[i] = g[i].size();
-        //         if (degree[i] <= 1) {
-        //             q.push(i);
-        //         }
-        //     }
-        //     int cnt = 0;
-        //     while (!q.empty()) {
-        //         cnt++;
-        //         int root = q.front();
-        //         q.pop();
-        //         for (auto child : g[root]) {
-        //             degree[child]--;
-        //             if (degree[child] == 1) {
-        //                 q.push(child);
-        //             }
-        //         }
-        //     }
-        //     return (cnt != n);
-        // }
         // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
         // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
         const statusMap: Map<V, TopologicalStatus> = new Map<V, TopologicalStatus>();
@@ -364,9 +352,8 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
             }
         }
 
-        if (hasCycle) {
-            return null;
-        }
+        if (hasCycle) return null;
+
         return sorted.reverse();
     }
 

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

@@ -1,18 +1,34 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import {arrayRemove} from '../../utils';
 import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
 import type {VertexId} from '../types';
 
 export class UndirectedVertex extends AbstractVertex {
+    /**
+     * The constructor function initializes an object with a given id.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
+     * vertex within a graph or network.
+     */
     constructor(id: VertexId) {
         super(id);
     }
 }
 
 export class UndirectedEdge extends AbstractEdge {
+    /**
+     * The constructor function initializes an instance of a class with two vertex IDs and an optional weight.
+     * @param {VertexId} v1 - The parameter `v1` is of type `VertexId` and represents the first vertex in the edge.
+     * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
+     * graph.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
+     * between two vertices.
+     */
     constructor(v1: VertexId, v2: VertexId, weight?: number) {
         super(weight);
         this._vertices = [v1, v2];

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

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 export class CoordinateMap<V> extends Map<any, V> {
     private readonly _joint: string = '_';

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

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 export class CoordinateSet extends Set {
     private readonly _joint: string = '_';

package/src/data-structures/heap/heap.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import {PriorityQueue} from '../priority-queue';
 import type {HeapItem, HeapOptions} from '../types';
@@ -59,37 +62,37 @@ export abstract class Heap<T> {
     }
 
     /**
-     * The `offer` function adds an element to a priority queue with an optional priority value.
+     * The `add` function adds an element to a priority queue with an optional priority value.
      * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * element being offered to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
+     * element being added to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
      * the value of `element`. If the `element` parameter is not a number, then the
-     * @returns The `offer` method returns the instance of the `Heap` class.
+     * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    offer(element: T, priority?: number): Heap<T> {
+    add(element: T, priority?: number): Heap<T> {
         if (typeof element === 'number') {
             priority = element;
         } else {
             if (priority === undefined) {
-                throw new Error('.offer expects a numeric priority');
+                throw new Error('.add expects a numeric priority');
             }
         }
 
         if (priority && Number.isNaN(+priority)) {
-            throw new Error('.offer expects a numeric priority');
+            throw new Error('.add expects a numeric priority');
         }
 
         if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(element))) {
             throw new Error(
-                '.offer expects a numeric priority '
+                '.add expects a numeric priority '
                 + 'or a constructor callback that returns a number'
             );
         }
 
         const _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.offer({priority: _priority, element});
+        this._pq.add({priority: _priority, element});
         return this;
     }
 

package/src/data-structures/heap/max-heap.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 
 import {Heap} from './heap';

package/src/data-structures/heap/min-heap.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 
 import {Heap} from './heap';

package/src/data-structures/index.ts

@@ -8,4 +8,6 @@ export * from './heap';
 export * from './priority-queue';
 export * from './matrix';
 export * from './trie';
+export * from './types';
+
 

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

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import type {DoublyLinkedListGetBy} from '../types';
 
@@ -34,7 +37,7 @@ export class DoublyLinkedList<T> {
      * the doubly linked list.
      * @returns A boolean value is being returned.
      */
-    offerFirst(val: T): boolean {
+    addFirst(val: T): boolean {
         const newNode = new DoublyLinkedListNode(val);
         if (this._size === 0) {
             this._first = newNode;
@@ -54,7 +57,7 @@ export class DoublyLinkedList<T> {
      * doubly linked list.
      * @returns a boolean value, which is always true.
      */
-    offerLast(val: T): boolean {
+    addLast(val: T): boolean {
         const newNode = new DoublyLinkedListNode(val);
         if (this._size === 0) {
             this._first = newNode;
@@ -247,8 +250,8 @@ export class DoublyLinkedList<T> {
      */
     insert(index: number, val: T): boolean {
         if (index < 0 || index > this._size) return false;
-        if (index === 0) return !!this.offerFirst(val);
-        if (index === this._size) return !!this.offerLast(val);
+        if (index === 0) return !!this.addFirst(val);
+        if (index === this._size) return !!this.addLast(val);
 
         const newNode = new DoublyLinkedListNode(val);
         const prevNode = this.get(index - 1, 'node');

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

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 
 /**

package/src/data-structures/matrix/matrix.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 // todo need to be improved
 export class MatrixNTI2D<T = number> {

package/src/data-structures/matrix/matrix2d.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import Vector2D from './vector2d'
 

package/src/data-structures/matrix/navigator.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import type {Direction, NavigatorParams, Turning} from '../types';
 

package/src/data-structures/matrix/vector2d.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 export class Vector2D {
     constructor(

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import {PriorityQueue} from './priority-queue';
 import type {PriorityQueueOptions} from '../types';

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import {PriorityQueue} from './priority-queue';
 import type {PriorityQueueOptions} from '../types';

package/src/data-structures/priority-queue/priority-queue.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import type {PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueueOptions} from '../types';
 
@@ -52,11 +55,11 @@ export class PriorityQueue<T = number> {
     }
 
     /**
-     * The "offer" function adds a node to the heap and ensures that the heap property is maintained.
+     * The "add" function adds a node to the heap and ensures that the heap property is maintained.
      * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node
      * that needs to be added to the heap.
      */
-    offer(node: T) {
+    add(node: T) {
         this.nodes.push(node);
         this._heapifyUp(this.size - 1);
     }

package/src/data-structures/queue/deque.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import {DoublyLinkedList} from '../linked-list';
 
@@ -28,7 +31,7 @@ export class ObjectDeque<T> {
         return this._size;
     }
 
-    offerFirst(value: T) {
+    addFirst(value: T) {
         if (this._size === 0) {
             const mid = Math.floor(this._capacity / 2);
             this._first = mid;
@@ -40,7 +43,7 @@ export class ObjectDeque<T> {
         this._size++;
     }
 
-    offerLast(value: T) {
+    addLast(value: T) {
         if (this._size === 0) {
             const mid = Math.floor(this._capacity / 2);
             this._first = mid;
@@ -98,11 +101,11 @@ export class ArrayDeque<T> {
     }
 
     /**
-     * The function "offerLast" adds a value to the end of an array.
+     * The function "addLast" adds a value to the end of an array.
      * @param {T} value - The value parameter represents the value that you want to add to the end of the array.
      * @returns The return value is the new length of the array after the value has been added.
      */
-    offerLast(value: T) {
+    addLast(value: T) {
         return this._nodes.push(value);
     }
 
@@ -124,12 +127,12 @@ export class ArrayDeque<T> {
     }
 
     /**
-     * The function "offerFirst" adds a value to the beginning of an array.
+     * The function "addFirst" adds a value to the beginning of an array.
      * @param {T} value - The value parameter represents the value that you want to add to the beginning of the array.
-     * @returns The return value of the `offerFirst` function is the new length of the array `_nodes` after adding the
+     * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
      * `value` at the beginning.
      */
-    offerFirst(value: T) {
+    addFirst(value: T) {
         return this._nodes.unshift(value);
     }
 

package/src/data-structures/queue/queue.ts

@@ -1,6 +1,6 @@
 /**
  * @license MIT
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 export class Queue<T> {
@@ -31,11 +31,11 @@ export class Queue<T> {
     }
 
     /**
-     * The offer function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
+     * The add function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
      * @param {T} element - The `element` parameter represents the element that you want to add to the queue.
-     * @returns The `offer` method is returning a `Queue<T>` object.
+     * @returns The `add` method is returning a `Queue<T>` object.
      */
-    offer(element: T): Queue<T> {
+    add(element: T): Queue<T> {
         this._nodes.push(element);
         return this;
     }

package/src/data-structures/stack/stack.ts

@@ -1,6 +1,6 @@
 /**
  * @license MIT
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 export class Stack<T> {

package/src/data-structures/trie/trie.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 export class TrieNode {
     protected _value;
@@ -45,7 +48,7 @@ export class Trie {
         this._root = new TrieNode('');
         if (words) {
             for (const i of words) {
-                this.put(i);
+                this.add(i);
             }
         }
     }
@@ -60,7 +63,7 @@ export class Trie {
         this._root = v;
     }
 
-    put(word: string): boolean {
+    add(word: string): boolean {
         let cur = this._root;
         for (const c of word) {
             let nodeC = cur.children.get(c);

package/src/utils/index.ts

@@ -1 +1,2 @@
-export * from './utils';
+export * from './utils';
+export * from './types';

package/src/utils/types/utils.ts

@@ -1,3 +1,12 @@
+export type JSONSerializable = {
+    [key: string]: any
+}
+export type JSONValue = string | number | boolean | undefined | JSONObject;
+
+export interface JSONObject {
+    [key: string]: JSONValue;
+}
+
 export type AnyFunction<A extends any[] = any[], R = any> = (...args: A) => R;
 export type Primitive =
     | number
@@ -32,16 +41,6 @@ export type DeepLeavesWrap<T, TComplex> =
 
 type Json = null | string | number | boolean | Json [] | { [name: string]: Json }
 
-export type JSONSerializable = {
-    [key: string]: any
-}
-
-export type JSONValue = string | number | boolean | undefined | JSONObject;
-
-export interface JSONObject {
-    [key: string]: JSONValue;
-}
-
 export type TypeName<T> = T extends string
     ? 'string'
     : T extends number
@@ -173,8 +172,7 @@ export type CurryFunc<T> = T extends (...args: infer Args) => infer R
 
 
 export type ToThunkFn = () => ReturnType<TrlFn>;
-const THUNK_SYMBOL = Symbol('thunk')
-export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: typeof THUNK_SYMBOL };
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: Symbol };
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;