data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,42 +1,50 @@
 /**
  * @license MIT
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
- *
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 export class Stack<T> {
     protected _elements: T[];
 
     /**
-     * Creates a stack.
-     * @param {array} [elements]
+     * The constructor initializes an array of elements, which can be provided as an optional parameter.
+     * @param {T[]} [elements] - The `elements` parameter is an optional parameter of type `T[]`, which represents an array
+     * of elements of type `T`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
+     * is provided and is an array, it is assigned to the `_elements
      */
     constructor(elements?: T[]) {
         this._elements = Array.isArray(elements) ? elements : [];
     }
 
     /**
-     * Checks if the stack is empty.
-     * @public
-     * @returns {boolean}
+     * The function "fromArray" creates a new Stack object from an array of elements.
+     * @param {T[]} elements - The `elements` parameter is an array of elements of type `T`.
+     * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
+     * array.
+     */
+    static fromArray<T>(elements: T[]): Stack<T> {
+        return new Stack(elements);
+    }
+
+    /**
+     * The function checks if an array is empty and returns a boolean value.
+     * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
     isEmpty(): boolean {
         return this._elements.length === 0;
     }
 
     /**
-     * Returns the number of elements in the stack.
-     * @public
-     * @returns {number}
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
      */
     size(): number {
         return this._elements.length;
     }
 
     /**
-     * Returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * The `peek` function returns the last element of an array, or null if the array is empty.
+     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
      */
     peek(): T | null {
         if (this.isEmpty()) return null;
@@ -45,9 +53,9 @@ export class Stack<T> {
     }
 
     /**
-     * Adds an element to the top of the stack.
-     * @public
-     * @param {object} element
+     * The push function adds an element to the stack and returns the updated stack.
+     * @param {T} element - The parameter "element" is of type T, which means it can be any data type.
+     * @returns The `push` method is returning the updated `Stack<T>` object.
      */
     push(element: T): Stack<T> {
         this._elements.push(element);
@@ -55,9 +63,9 @@ export class Stack<T> {
     }
 
     /**
-     * Removes and returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+     * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
+     * array is empty, it returns `null`.
      */
     pop(): T | null {
         if (this.isEmpty()) return null;
@@ -66,39 +74,25 @@ export class Stack<T> {
     }
 
     /**
-     * Returns the remaining elements as an array.
-     * @public
-     * @returns {array}
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type T.
      */
     toArray(): T[] {
         return this._elements.slice();
     }
 
     /**
-     * Clears all elements from the stack.
-     * @public
+     * The clear function clears the elements array.
      */
     clear(): void {
         this._elements = [];
     }
 
     /**
-     * Creates a shallow copy from the stack.
-     * @public
-     * @return {Stack}
+     * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
+     * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
     clone(): Stack<T> {
         return new Stack(this._elements.slice());
     }
-
-    /**
-     * Creates a stack from an existing array
-     * @public
-     * @static
-     * @param {array} [elements]
-     * @return {Stack}
-     */
-    static fromArray<T>(elements: T[]): Stack<T> {
-        return new Stack(elements);
-    }
 }

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

@@ -1,5 +1,17 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 export class TrieNode {
-    protected _children: Map<string, TrieNode> = new Map<string, TrieNode>();
+    protected _value;
+
+    constructor(v: string) {
+        this._value = v;
+        this._isEnd = false;
+        this._children = new Map<string, TrieNode>();
+    }
+
+    protected _children: Map<string, TrieNode>;
 
     get children(): Map<string, TrieNode> {
         return this._children;
@@ -9,7 +21,7 @@ export class TrieNode {
         this._children = v;
     }
 
-    protected _isEnd = false;
+    protected _isEnd: boolean;
 
     get isEnd(): boolean {
         return this._isEnd;
@@ -18,10 +30,28 @@ export class TrieNode {
     set isEnd(v: boolean) {
         this._isEnd = v;
     }
+
+    get val(): string {
+        return this._value;
+    }
+
+    set val(v: string) {
+        this._value = v;
+    }
 }
 
 export class Trie {
+    constructor(words?: string[]) {
+        this._root = new TrieNode('');
+        if (words) {
+            for (const i of words) {
+                this.put(i);
+            }
+        }
+    }
+
     protected _root: TrieNode;
+
     get root() {
         return this._root;
     }
@@ -30,16 +60,12 @@ export class Trie {
         this._root = v;
     }
 
-    constructor() {
-        this._root = new TrieNode();
-    }
-
-    put(input: string): boolean {
+    put(word: string): boolean {
         let cur = this._root;
-        for (const c of input) {
+        for (const c of word) {
             let nodeC = cur.children.get(c);
             if (!nodeC) {
-                nodeC = new TrieNode();
+                nodeC = new TrieNode(c);
                 cur.children.set(c, nodeC);
             }
             cur = nodeC;
@@ -48,7 +74,6 @@ export class Trie {
         return true;
     }
 
-
     has(input: string): boolean {
         let cur = this._root;
         for (const c of input) {
@@ -93,8 +118,9 @@ export class Trie {
 
     // --- start additional methods ---
     /**
-     * Only can present as a prefix, not a word
-     * @param input
+     * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
+     * @param {string} input - The input parameter is a string that represents the input value for the function.
+     * @returns a boolean value.
      */
     isAbsPrefix(input: string): boolean {
         let cur = this._root;
@@ -107,8 +133,9 @@ export class Trie {
     }
 
     /**
-     * Can present as a prefix or word
-     * @param input
+     * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
+     * @param {string} input - The input parameter is a string that represents the prefix we want to check.
+     * @returns a boolean value.
      */
     isPrefix(input: string): boolean {
         let cur = this._root;
@@ -120,7 +147,49 @@ export class Trie {
         return true;
     }
 
+    /**
+     * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
+     * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
+     * in the Trie data structure.
+     * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
+     */
+    isCommonPrefix(input: string): boolean {
+        let commonPre = '';
+        const dfs = (cur: TrieNode) => {
+            commonPre += cur.val;
+            if (commonPre === input) return;
+            if (cur.isEnd) return;
+            if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
+            else return;
+        }
+        dfs(this._root);
+        return commonPre === input;
+    }
 
+    /**
+     * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
+     * structure.
+     * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
+     * Trie.
+     */
+    getLongestCommonPrefix(): string {
+        let commonPre = '';
+        const dfs = (cur: TrieNode) => {
+            commonPre += cur.val;
+            if (cur.isEnd) return;
+            if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
+            else return;
+        }
+        dfs(this._root);
+        return commonPre;
+    }
+
+    /**
+     * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
+     * @param [prefix] - The `prefix` parameter is a string that represents the prefix that we want to search for in the
+     * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
+     * @returns an array of strings.
+     */
     getAll(prefix = ''): string[] {
         const words: string[] = [];
 

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

@@ -0,0 +1,51 @@
+export type VertexId = string | number;
+export type DijkstraResult<V> =
+    { distMap: Map<V, number>, preMap: Map<V, V | null>, seen: Set<V>, paths: V[][], minDist: number, minPath: V[] }
+    | null;
+
+export interface IGraph<V, E> {
+
+    containsVertex(vertexOrId: V | VertexId): boolean;
+
+    getVertex(vertexOrId: VertexId | V): V | null;
+
+    getVertexId(vertexOrId: V | VertexId): VertexId;
+
+    vertexSet(): Map<VertexId, V>;
+
+    addVertex(v: V): boolean;
+
+    removeVertex(vertexOrId: V | VertexId): boolean;
+
+    removeAllVertices(vertices: V[] | VertexId[]): boolean;
+
+    degreeOf(vertexOrId: V | VertexId): number;
+
+    edgesOf(vertexOrId: V | VertexId): E[];
+
+    containsEdge(src: V | VertexId, dest: V | VertexId): boolean;
+
+    // containsEdge(e: E): boolean;
+
+    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+
+    // getAllEdges(src: V, dest: V): E[];
+
+    edgeSet(): E[];
+
+    addEdge(edge: E): boolean;
+
+    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+
+    removeEdge(edge: E): E | null;
+
+    // removeAllEdges(v1: VertexId | V, v2: VertexId | V): (E | null)[];
+
+    // removeAllEdges(edges: E[] | [VertexId, VertexId]): boolean;
+
+    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
+
+    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
+
+    getNeighbors(vertexOrId: V | VertexId): V[];
+}

package/src/data-structures/types/avl-tree.ts

@@ -0,0 +1,6 @@
+import {AVLTreeNode} from '../binary-tree';
+
+export interface AVLTreeDeleted<T> {
+    deleted: AVLTreeNode<T> | null;
+    needBalanced: AVLTreeNode<T> | null;
+}

package/src/data-structures/types/binary-tree.ts

@@ -0,0 +1,15 @@
+import {BinaryTreeNode} from '../binary-tree';
+
+export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeId = number;
+export type BinaryTreeDeleted<T> = { deleted: BinaryTreeNode<T> | null | undefined, needBalanced: BinaryTreeNode<T> | null };
+export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
+export type ResultsByProperty<T> = ResultByProperty<T>[];
+
+export interface BinaryTreeNodeObj<T> {
+    id: BinaryTreeNodeId;
+    val: T;
+    count?: number;
+}

package/src/data-structures/types/bst.ts

@@ -0,0 +1,5 @@
+import {BSTNode} from '../binary-tree';
+import type {BinaryTreeNodeId} from './binary-tree';
+
+export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
+export type BSTDeletedResult<T> = { deleted: BSTNode<T> | null, needBalanced: BSTNode<T> | null };

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

@@ -0,0 +1,18 @@
+import {VertexId} from './abstract-graph';
+
+export interface IDirectedGraph<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;

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

@@ -0,0 +1 @@
+export type DoublyLinkedListGetBy = 'node' | 'val';

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

@@ -0,0 +1,8 @@
+export interface HeapOptions<T> {
+    priority?: (element: T) => number;
+}
+
+export interface HeapItem<T> {
+    priority: number;
+    element: T | null;
+}

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

@@ -0,0 +1,13 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './avl-tree';
+export * from './segment-tree';
+export * from './tree-multiset';
+export * from './abstract-graph';
+export * from './directed-graph';
+export * from './priority-queue';
+export * from './heap';
+export * from './singly-linked-list';
+export * from './doubly-linked-list';
+export * from './navigator';
+export * from '../../utils/types/utils';

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

@@ -0,0 +1,13 @@
+export type Direction = 'up' | 'right' | 'down' | 'left';
+export type Turning = { [key in Direction]: Direction };
+
+export interface NavigatorParams<T> {
+    matrix: T[][],
+    turning: Turning,
+    onMove: (cur: [number, number]) => void
+    init: {
+        cur: [number, number],
+        charDir: Direction,
+        VISITED: T,
+    }
+}

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

@@ -0,0 +1,9 @@
+export type PriorityQueueComparator<T> = (a: T, b: T) => number;
+
+export interface PriorityQueueOptions<T> {
+    nodes?: T[];
+    isFix?: boolean;
+    comparator: PriorityQueueComparator<T>;
+}
+
+export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';

package/src/data-structures/types/segment-tree.ts

@@ -0,0 +1 @@
+export type SegmentTreeNodeVal = number;

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

@@ -0,0 +1 @@
+export {}

package/src/data-structures/types/tree-multiset.ts

@@ -0,0 +1,3 @@
+import {BSTNode} from '../binary-tree';
+
+export type TreeMultiSetDeletedResult<T> = { deleted: BSTNode<T> | null, needBalanced: BSTNode<T> | null };

package/src/utils/index.ts

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

package/src/utils/trampoline.ts

@@ -0,0 +1,51 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import {Thunk, ToThunkFn, TrlAsyncFn, TrlFn} from './types';
+
+export const THUNK_SYMBOL = Symbol('thunk')
+
+export const isThunk = (fnOrValue: any) => {
+    return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === THUNK_SYMBOL
+}
+
+export const toThunk = (fn: ToThunkFn): Thunk => {
+    const thunk = () => fn()
+    thunk.__THUNK__ = THUNK_SYMBOL
+    return thunk
+}
+
+export const trampoline = (fn: TrlFn) => {
+    const cont = (...args: [...Parameters<TrlFn>]) => toThunk(() => fn(...args))
+
+    return Object.assign(
+        (...args: [...Parameters<TrlFn>]) => {
+            let result = fn(...args)
+
+            while (isThunk(result) && typeof result === 'function') {
+                result = result()
+            }
+
+            return result
+        },
+        {cont}
+    )
+}
+
+export const trampolineAsync = (fn: TrlAsyncFn) => {
+    const cont = (...args: [...Parameters<TrlAsyncFn>]) => toThunk(() => fn(...args))
+
+    return Object.assign(
+        async (...args: [...Parameters<TrlAsyncFn>]) => {
+            let result = await fn(...args)
+
+            while (isThunk(result) && typeof result === 'function') {
+                result = await result()
+            }
+
+            return result
+        },
+        {cont}
+    )
+}

package/src/utils/types/index.ts

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

package/src/{types → utils/types}/utils.ts

@@ -74,9 +74,9 @@ export type DebounceOptions = {
 };
 
 export interface DebouncedFunction<F extends Procedure> {
-    (this: ThisParameterType<F>, ...args: Parameters<F>): void;
-
     cancel: () => void;
+
+    (this: ThisParameterType<F>, ...args: [...Parameters<F>]): void;
 }
 
 export type MonthKey =
@@ -123,10 +123,10 @@ export class TreeNode<T> {
         if (!this.children) {
             this.children = [];
         }
-        if (children instanceof Array) {
-            this.children = this.children.concat(children);
-        } else {
+        if (children instanceof TreeNode) {
             this.children.push(children);
+        } else {
+            this.children = this.children.concat(children);
         }
     }
 
@@ -155,4 +155,26 @@ export class TreeNode<T> {
 
 export type OrderType = 'InOrder' | 'PreOrder' | 'PostOrder'
 
+export type DeepProxy<T> = T extends (...args: any[]) => infer R
+    ? (...args: [...Parameters<T>]) => DeepProxy<R>
+    : T extends object
+        ? { [K in keyof T]: DeepProxy<T[K]> }
+        : T;
+
+export type DeepProxyOnChange = (target: any, property: string | symbol, value: any, receiver: any, descriptor: any, result: any) => void;
+
+export type DeepProxyOnGet = (target: any, property: string | symbol, value: any, receiver: any, descriptor: any, result: any) => void;
+
+export type CurryFunc<T> = T extends (...args: infer Args) => infer R
+    ? Args extends [infer Arg, ...infer RestArgs]
+        ? (arg: Arg) => CurryFunc<(...args: RestArgs) => R>
+        : R
+    : T;
+
+
+export type ToThunkFn = () => ReturnType<TrlFn>;
+const THUNK_SYMBOL = Symbol('thunk')
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: typeof THUNK_SYMBOL };
+export type TrlFn = (...args: any[]) => any;
+export type TrlAsyncFn = (...args: any[]) => any;