data-structure-typed 0.8.18 → 0.9.16

package/dist/data-structures/trie/trie.js

@@ -1,63 +1,136 @@
 "use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = exports.TrieNode = void 0;
-class TrieNode {
-    constructor() {
-        this._children = new Map();
+var TrieNode = /** @class */ (function () {
+    function TrieNode(v) {
+        this._value = v;
         this._isEnd = false;
+        this._children = new Map();
     }
-    get children() {
-        return this._children;
-    }
-    set children(v) {
-        this._children = v;
-    }
-    get isEnd() {
-        return this._isEnd;
-    }
-    set isEnd(v) {
-        this._isEnd = v;
-    }
-}
+    Object.defineProperty(TrieNode.prototype, "children", {
+        get: function () {
+            return this._children;
+        },
+        set: function (v) {
+            this._children = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TrieNode.prototype, "isEnd", {
+        get: function () {
+            return this._isEnd;
+        },
+        set: function (v) {
+            this._isEnd = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TrieNode.prototype, "val", {
+        get: function () {
+            return this._value;
+        },
+        set: function (v) {
+            this._value = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TrieNode;
+}());
 exports.TrieNode = TrieNode;
-class Trie {
-    get root() {
-        return this._root;
-    }
-    set root(v) {
-        this._root = v;
-    }
-    constructor() {
-        this._root = new TrieNode();
+var Trie = /** @class */ (function () {
+    function Trie(words) {
+        var e_1, _a;
+        this._root = new TrieNode('');
+        if (words) {
+            try {
+                for (var words_1 = __values(words), words_1_1 = words_1.next(); !words_1_1.done; words_1_1 = words_1.next()) {
+                    var i = words_1_1.value;
+                    this.put(i);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (words_1_1 && !words_1_1.done && (_a = words_1.return)) _a.call(words_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
     }
-    put(input) {
-        let cur = this._root;
-        for (const c of input) {
-            let nodeC = cur.children.get(c);
-            if (!nodeC) {
-                nodeC = new TrieNode();
-                cur.children.set(c, nodeC);
-            }
-            cur = nodeC;
+    Object.defineProperty(Trie.prototype, "root", {
+        get: function () {
+            return this._root;
+        },
+        set: function (v) {
+            this._root = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Trie.prototype.put = function (word) {
+        var e_2, _a;
+        var cur = this._root;
+        try {
+            for (var word_1 = __values(word), word_1_1 = word_1.next(); !word_1_1.done; word_1_1 = word_1.next()) {
+                var c = word_1_1.value;
+                var nodeC = cur.children.get(c);
+                if (!nodeC) {
+                    nodeC = new TrieNode(c);
+                    cur.children.set(c, nodeC);
+                }
+                cur = nodeC;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (word_1_1 && !word_1_1.done && (_a = word_1.return)) _a.call(word_1);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
         cur.isEnd = true;
         return true;
-    }
-    has(input) {
-        let cur = this._root;
-        for (const c of input) {
-            const nodeC = cur.children.get(c);
-            if (!nodeC)
-                return false;
-            cur = nodeC;
+    };
+    Trie.prototype.has = function (input) {
+        var e_3, _a;
+        var cur = this._root;
+        try {
+            for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
+                var c = input_1_1.value;
+                var nodeC = cur.children.get(c);
+                if (!nodeC)
+                    return false;
+                cur = nodeC;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1);
+            }
+            finally { if (e_3) throw e_3.error; }
         }
         return cur.isEnd;
-    }
-    remove(word) {
-        let isDeleted = false;
-        const dfs = (cur, i) => {
-            const char = word[i];
-            const child = cur.children.get(char);
+    };
+    Trie.prototype.remove = function (word) {
+        var isDeleted = false;
+        var dfs = function (cur, i) {
+            var char = word[i];
+            var child = cur.children.get(char);
             if (child) {
                 if (i === word.length - 1) {
                     if (child.isEnd) {
@@ -72,7 +145,7 @@ class Trie {
                     }
                     return false;
                 }
-                const res = dfs(child, i + 1);
+                var res = dfs(child, i + 1);
                 if (res && !cur.isEnd && child.children.size === 0) {
                     cur.children.delete(char);
                     return true;
@@ -83,59 +156,140 @@ class Trie {
         };
         dfs(this.root, 0);
         return isDeleted;
-    }
+    };
     // --- start additional methods ---
     /**
      * Only can present as a prefix, not a word
      * @param input
      */
-    isAbsPrefix(input) {
-        let cur = this._root;
-        for (const c of input) {
-            const nodeC = cur.children.get(c);
-            if (!nodeC)
-                return false;
-            cur = nodeC;
+    Trie.prototype.isAbsPrefix = function (input) {
+        var e_4, _a;
+        var cur = this._root;
+        try {
+            for (var input_2 = __values(input), input_2_1 = input_2.next(); !input_2_1.done; input_2_1 = input_2.next()) {
+                var c = input_2_1.value;
+                var nodeC = cur.children.get(c);
+                if (!nodeC)
+                    return false;
+                cur = nodeC;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (input_2_1 && !input_2_1.done && (_a = input_2.return)) _a.call(input_2);
+            }
+            finally { if (e_4) throw e_4.error; }
         }
         return !cur.isEnd;
-    }
+    };
     /**
-     * Can present as a prefix or word
+     * Can present as a abs prefix or word
      * @param input
      */
-    isPrefix(input) {
-        let cur = this._root;
-        for (const c of input) {
-            const nodeC = cur.children.get(c);
-            if (!nodeC)
-                return false;
-            cur = nodeC;
+    Trie.prototype.isPrefix = function (input) {
+        var e_5, _a;
+        var cur = this._root;
+        try {
+            for (var input_3 = __values(input), input_3_1 = input_3.next(); !input_3_1.done; input_3_1 = input_3.next()) {
+                var c = input_3_1.value;
+                var nodeC = cur.children.get(c);
+                if (!nodeC)
+                    return false;
+                cur = nodeC;
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (input_3_1 && !input_3_1.done && (_a = input_3.return)) _a.call(input_3);
+            }
+            finally { if (e_5) throw e_5.error; }
         }
         return true;
-    }
-    getAll(prefix = '') {
-        const words = [];
+    };
+    /**
+     * Check if the input string is the common prefix of all the words
+     * @param input
+     */
+    Trie.prototype.isCommonPrefix = function (input) {
+        var commonPre = '';
+        var dfs = function (cur) {
+            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
+    Trie.prototype.getLongestCommonPrefix = function () {
+        var commonPre = '';
+        var dfs = function (cur) {
+            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;
+    };
+    Trie.prototype.getAll = function (prefix) {
+        var e_6, _a;
+        if (prefix === void 0) { prefix = ''; }
+        var words = [];
         function dfs(node, word) {
-            for (const char of node.children.keys()) {
-                const charNode = node.children.get(char);
-                if (charNode !== undefined) {
-                    dfs(charNode, word.concat(char));
+            var e_7, _a;
+            try {
+                for (var _b = __values(node.children.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var char = _c.value;
+                    var charNode = node.children.get(char);
+                    if (charNode !== undefined) {
+                        dfs(charNode, word.concat(char));
+                    }
                 }
             }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
             if (node.isEnd) {
                 words.push(word);
             }
         }
-        let startNode = this._root;
+        var startNode = this._root;
         if (prefix) {
-            for (const c of prefix) {
-                const nodeC = startNode.children.get(c);
-                if (nodeC)
-                    startNode = nodeC;
+            try {
+                for (var prefix_1 = __values(prefix), prefix_1_1 = prefix_1.next(); !prefix_1_1.done; prefix_1_1 = prefix_1.next()) {
+                    var c = prefix_1_1.value;
+                    var nodeC = startNode.children.get(c);
+                    if (nodeC)
+                        startNode = nodeC;
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (prefix_1_1 && !prefix_1_1.done && (_a = prefix_1.return)) _a.call(prefix_1);
+                }
+                finally { if (e_6) throw e_6.error; }
             }
         }
         dfs(startNode, prefix);
         return words;
-    }
-}
+    };
+    return Trie;
+}());
 exports.Trie = Trie;

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

@@ -0,0 +1,29 @@
+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;
+    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    edgeSet(): E[];
+    addEdge(edge: E): boolean;
+    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    removeEdge(edge: E): E | null;
+    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/dist/data-structures/types/abstract-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/avl-tree.d.ts

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

package/dist/data-structures/types/avl-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/binary-tree.d.ts

@@ -0,0 +1,16 @@
+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/dist/data-structures/types/binary-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/bst.d.ts

@@ -0,0 +1,7 @@
+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/dist/data-structures/types/bst.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,10 @@
+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;
+}
+export type TopologicalStatus = 0 | 1 | 2;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/doubly-linked-list.d.ts

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

package/dist/data-structures/types/doubly-linked-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/heap.d.ts

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

package/dist/data-structures/types/heap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/index.d.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/dist/data-structures/types/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./binary-tree"), exports);
+__exportStar(require("./bst"), exports);
+__exportStar(require("./avl-tree"), exports);
+__exportStar(require("./segment-tree"), exports);
+__exportStar(require("./tree-multiset"), exports);
+__exportStar(require("./abstract-graph"), exports);
+__exportStar(require("./directed-graph"), exports);
+__exportStar(require("./priority-queue"), exports);
+__exportStar(require("./heap"), exports);
+__exportStar(require("./singly-linked-list"), exports);
+__exportStar(require("./doubly-linked-list"), exports);
+__exportStar(require("./navigator"), exports);
+__exportStar(require("./utils"), exports);

package/dist/data-structures/types/navigator.d.ts

@@ -0,0 +1,14 @@
+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/dist/data-structures/types/navigator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/priority-queue.d.ts

@@ -0,0 +1,7 @@
+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/dist/data-structures/types/priority-queue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/segment-tree.d.ts

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

package/dist/data-structures/types/segment-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/singly-linked-list.d.ts

@@ -0,0 +1,5 @@
+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/dist/data-structures/types/singly-linked-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/types/tree-multiset.d.ts

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

package/dist/data-structures/types/tree-multiset.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{types → data-structures/types}/utils.d.ts

@@ -26,8 +26,8 @@ export type DebounceOptions = {
     maxWait?: number;
 };
 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 = 'January' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
 export type Month = {
@@ -44,3 +44,9 @@ export declare class TreeNode<T> {
     getHeight(): number;
 }
 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;