data-structure-typed 0.8.18 → 0.9.16

package/src/data-structures/trampoline.ts

@@ -1,91 +1,51 @@
-export type ArgumentTypes<T extends (...args: any[]) => any> =
-    T extends (...args: infer A) => any
-        ? A
-        : never;
+export const THUNK_SYMBOL = Symbol('thunk')
 
-export const THUNK_SYMBOL: unique symbol = Symbol('thunk');
-
-export interface Thunk<T> extends Function {
-    __THUNK__: typeof THUNK_SYMBOL;
-
-    (): T;
+export const isThunk = (fnOrValue: any) => {
+    return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === THUNK_SYMBOL
 }
 
-export type ThunkOrValue<T> = T | Thunk<T>;
-
-export type UnwrapThunkDeep<T> = {
-    0: T extends Thunk<infer U> ? UnwrapThunkDeep<U> : T;
-}[
-    T extends ThunkOrValue<T> ? 0 : never
-    ];
-
-export const isThunk = <T>(value: any): value is Thunk<T> => {
-    return typeof value === 'function' && value.__THUNK__ === THUNK_SYMBOL;
-};
-
-export const toThunk = <R>(fn: () => R): Thunk<R> => {
-    const thunk = () => fn();
-    thunk.__THUNK__ = THUNK_SYMBOL;
-    return thunk;
-};
-export type UnwrapPromise<T> = T extends Promise<infer U> ? Exclude<U, Promise<T>> : T;
-
-export type Unbox<T> = UnwrapThunkDeep<UnwrapPromise<T>>;
-
-export type Cont<A extends any[], R> = (...args: A) => Thunk<Unbox<R>>;
+type ToThunkFn = () => ReturnType<TrlFn>;
 
-export interface Trampoline<F extends ((...args: any[]) => any)> {
-    (...args: ArgumentTypes<F>): Unbox<ReturnType<F>>;
+type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: typeof THUNK_SYMBOL };
 
-    cont: Cont<ArgumentTypes<F>, ReturnType<F>>;
+export const toThunk = (fn: ToThunkFn): Thunk => {
+    const thunk = () => fn()
+    thunk.__THUNK__ = THUNK_SYMBOL
+    return thunk
 }
 
-export interface TrampolineAsync<F extends ((...args: any[]) => any)> {
-    (...args: ArgumentTypes<F>): Promise<Unbox<ReturnType<F>>>;
-
-    cont: Cont<ArgumentTypes<F>, ReturnType<F>>;
-}
-
-export const trampoline = <F extends ((...args: any[]) => any)>(fn: F): Trampoline<F> => {
-    const cont = (...args: ArgumentTypes<F>) => toThunk(() => fn(...args));
+type TrlFn = (...args: any[]) => any;
+export const trampoline = (fn: TrlFn) => {
+    const cont = (...args: [...Parameters<TrlFn>]) => toThunk(() => fn(...args))
 
     return Object.assign(
-        (...args: ArgumentTypes<F>): Unbox<ReturnType<F>> => {
-            let result: ThunkOrValue<ReturnType<F>> = fn(...args);
+        (...args: [...Parameters<TrlFn>]) => {
+            let result = fn(...args)
 
-            while (isThunk<ReturnType<F>>(result)) {
-                result = result();
+            while (isThunk(result) && typeof result === 'function') {
+                result = result()
             }
 
-            return result;
+            return result
         },
-        {cont},
-    );
-};
+        {cont}
+    )
+}
 
-export const trampolineAsync = <F extends ((...args: any[]) => any)>(fn: F): TrampolineAsync<F> => {
-    const cont = (...args: ArgumentTypes<F>) => toThunk(() => fn(...args));
+type TrlAsyncFn = (...args: any[]) => any;
+export const trampolineAsync = (fn: TrlAsyncFn) => {
+    const cont = (...args: [...Parameters<TrlAsyncFn>]) => toThunk(() => fn(...args))
 
     return Object.assign(
-        async (...args: ArgumentTypes<F>): Promise<Unbox<ReturnType<F>>> => {
-            let result: ThunkOrValue<ReturnType<F>> = await fn(...args);
+        async (...args: [...Parameters<TrlAsyncFn>]) => {
+            let result = await fn(...args)
 
-            while (isThunk<ReturnType<F>>(result)) {
-                result = await result();
+            while (isThunk(result) && typeof result === 'function') {
+                result = await result()
             }
 
-            return result;
+            return result
         },
-        {cont},
-    );
-};
-
-
-const factorial = trampoline((n: number, acc: number = 1): ThunkOrValue<number> => {
-    return n
-        // Note: calling factorial.cont instead of factorial directly
-        ? factorial.cont(n - 1, acc * n)
-        : acc;
-});
-
-// factorial(32768)
+        {cont}
+    )
+}

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

@@ -1,5 +1,13 @@
 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 +17,7 @@ export class TrieNode {
         this._children = v;
     }
 
-    protected _isEnd = false;
+    protected _isEnd: boolean;
 
     get isEnd(): boolean {
         return this._isEnd;
@@ -18,10 +26,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 +56,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 +70,6 @@ export class Trie {
         return true;
     }
 
-
     has(input: string): boolean {
         let cur = this._root;
         for (const c of input) {
@@ -107,7 +128,7 @@ export class Trie {
     }
 
     /**
-     * Can present as a prefix or word
+     * Can present as a abs prefix or word
      * @param input
      */
     isPrefix(input: string): boolean {
@@ -120,6 +141,35 @@ export class Trie {
         return true;
     }
 
+    /**
+     * Check if the input string is the common prefix of all the words
+     * @param input
+     */
+    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;
+    }
+
+    // Retrieve the longest common prefix of all the words
+    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;
+    }
 
     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';

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

@@ -0,0 +1,12 @@
+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,15 @@
+import { SinglyLinkedList } from "../linked-list";
+
+/** Type used for filter and find methods, returning a boolean */
+export type TTestFunction<NodeData> = (
+    data: NodeData,
+    index: number,
+    list: SinglyLinkedList<NodeData>,
+) => boolean;
+
+/** Type used for map and forEach methods, returning anything */
+export type TMapFunction<NodeData> = (
+    data: any,
+    index: number,
+    list: SinglyLinkedList<NodeData>,
+) => any;

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/{types → data-structures/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,19 @@ 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;
 

package/src/utils/index.ts

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