data-structure-typed 1.19.2 → 1.19.4

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

@@ -1,43 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeNode = void 0;
-var TreeNode = /** @class */ (function () {
-    function TreeNode(id, value, children) {
+class TreeNode {
+    constructor(id, value, children) {
         this._id = id;
         this._value = value || undefined;
         this._children = children || [];
     }
-    Object.defineProperty(TreeNode.prototype, "id", {
-        get: function () {
-            return this._id;
-        },
-        set: function (value) {
-            this._id = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TreeNode.prototype, "value", {
-        get: function () {
-            return this._value;
-        },
-        set: function (value) {
-            this._value = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TreeNode.prototype, "children", {
-        get: function () {
-            return this._children;
-        },
-        set: function (value) {
-            this._children = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    TreeNode.prototype.addChildren = function (children) {
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get children() {
+        return this._children;
+    }
+    set children(value) {
+        this._children = value;
+    }
+    addChildren(children) {
         if (!this.children) {
             this.children = [];
         }
@@ -47,27 +35,26 @@ var TreeNode = /** @class */ (function () {
         else {
             this.children = this.children.concat(children);
         }
-    };
-    TreeNode.prototype.getHeight = function () {
+    }
+    getHeight() {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
-        var beginRoot = this;
-        var maxDepth = 1;
+        const beginRoot = this;
+        let maxDepth = 1;
         if (beginRoot) {
-            var bfs_1 = function (node, level) {
+            const bfs = (node, level) => {
                 if (level > maxDepth) {
                     maxDepth = level;
                 }
-                var children = node.children;
+                const { children } = node;
                 if (children) {
-                    for (var i = 0, len = children.length; i < len; i++) {
-                        bfs_1(children[i], level + 1);
+                    for (let i = 0, len = children.length; i < len; i++) {
+                        bfs(children[i], level + 1);
                     }
                 }
             };
-            bfs_1(beginRoot, 1);
+            bfs(beginRoot, 1);
         }
         return maxDepth;
-    };
-    return TreeNode;
-}());
+    }
+}
 exports.TreeNode = TreeNode;

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

@@ -1,15 +1,4 @@
 "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;
 /**
@@ -19,125 +8,75 @@ exports.Trie = exports.TrieNode = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-var TrieNode = /** @class */ (function () {
-    function TrieNode(v) {
+class TrieNode {
+    constructor(v) {
         this._val = v;
         this._isEnd = false;
         this._children = new Map();
     }
-    Object.defineProperty(TrieNode.prototype, "val", {
-        get: function () {
-            return this._val;
-        },
-        set: function (v) {
-            this._val = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    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
-    });
-    return TrieNode;
-}());
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        this._val = v;
+    }
+    get children() {
+        return this._children;
+    }
+    set children(v) {
+        this._children = v;
+    }
+    get isEnd() {
+        return this._isEnd;
+    }
+    set isEnd(v) {
+        this._isEnd = v;
+    }
+}
 exports.TrieNode = TrieNode;
-var Trie = /** @class */ (function () {
-    function Trie(words) {
-        var e_1, _a;
+class Trie {
+    constructor(words) {
         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.add(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; }
+            for (const i of words) {
+                this.add(i);
             }
         }
     }
-    Object.defineProperty(Trie.prototype, "root", {
-        get: function () {
-            return this._root;
-        },
-        set: function (v) {
-            this._root = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Trie.prototype.add = 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; }
+    get root() {
+        return this._root;
+    }
+    set root(v) {
+        this._root = v;
+    }
+    add(word) {
+        let cur = this._root;
+        for (const c of word) {
+            let nodeC = cur.children.get(c);
+            if (!nodeC) {
+                nodeC = new TrieNode(c);
+                cur.children.set(c, nodeC);
+            }
+            cur = nodeC;
         }
         cur.isEnd = true;
         return true;
-    };
-    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; }
+    }
+    has(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
         }
         return cur.isEnd;
-    };
-    Trie.prototype.remove = function (word) {
-        var isDeleted = false;
-        var dfs = function (cur, i) {
-            var char = word[i];
-            var child = cur.children.get(char);
+    }
+    remove(word) {
+        let isDeleted = false;
+        const dfs = (cur, i) => {
+            const char = word[i];
+            const child = cur.children.get(char);
             if (child) {
                 if (i === word.length - 1) {
                     if (child.isEnd) {
@@ -152,7 +91,7 @@ var Trie = /** @class */ (function () {
                     }
                     return false;
                 }
-                var res = dfs(child, i + 1);
+                const res = dfs(child, i + 1);
                 if (res && !cur.isEnd && child.children.size === 0) {
                     cur.children.delete(char);
                     return true;
@@ -163,69 +102,47 @@ var Trie = /** @class */ (function () {
         };
         dfs(this.root, 0);
         return isDeleted;
-    };
+    }
     // --- start additional methods ---
     /**
      * 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.
      */
-    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; }
+    isAbsPrefix(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
         }
         return !cur.isEnd;
-    };
+    }
     /**
      * 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.
      */
-    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; }
+    isPrefix(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
         }
         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.
      */
-    Trie.prototype.isCommonPrefix = function (input) {
-        var commonPre = '';
-        var dfs = function (cur) {
+    isCommonPrefix(input) {
+        let commonPre = '';
+        const dfs = (cur) => {
             commonPre += cur.val;
             if (commonPre === input)
                 return;
@@ -238,16 +155,16 @@ var Trie = /** @class */ (function () {
         };
         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.
      */
-    Trie.prototype.getLongestCommonPrefix = function () {
-        var commonPre = '';
-        var dfs = function (cur) {
+    getLongestCommonPrefix() {
+        let commonPre = '';
+        const dfs = (cur) => {
             commonPre += cur.val;
             if (cur.isEnd)
                 return;
@@ -258,60 +175,36 @@ var Trie = /** @class */ (function () {
         };
         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.
      */
-    Trie.prototype.getAll = function (prefix) {
-        var e_6, _a;
-        if (prefix === void 0) { prefix = ''; }
-        var words = [];
+    getAll(prefix = '') {
+        const words = [];
         function dfs(node, word) {
-            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));
-                    }
+            for (const char of node.children.keys()) {
+                const 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);
             }
         }
-        var startNode = this._root;
+        let startNode = this._root;
         if (prefix) {
-            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; }
+            for (const c of prefix) {
+                const nodeC = startNode.children.get(c);
+                if (nodeC)
+                    startNode = nodeC;
             }
         }
         dfs(startNode, prefix);
         return words;
-    };
-    return Trie;
-}());
+    }
+}
 exports.Trie = Trie;

package/dist/utils/utils.js

@@ -8,72 +8,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
-var uuidV4 = function () {
+const uuidV4 = function () {
     return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
-        var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+        const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
         return v.toString(16);
     });
 };
 exports.uuidV4 = uuidV4;
-var arrayRemove = function (array, predicate) {
-    var i = -1, len = array ? array.length : 0;
-    var result = [];
+const arrayRemove = function (array, predicate) {
+    let i = -1, len = array ? array.length : 0;
+    const result = [];
     while (++i < len) {
-        var value = array[i];
+        const value = array[i];
         if (predicate(value, i, array)) {
             result.push(value);
             Array.prototype.splice.call(array, i--, 1);
@@ -84,68 +32,35 @@ var arrayRemove = function (array, predicate) {
 };
 exports.arrayRemove = arrayRemove;
 exports.THUNK_SYMBOL = Symbol('thunk');
-var isThunk = function (fnOrValue) {
+const isThunk = (fnOrValue) => {
     return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === exports.THUNK_SYMBOL;
 };
 exports.isThunk = isThunk;
-var toThunk = function (fn) {
-    var thunk = function () { return fn(); };
+const toThunk = (fn) => {
+    const thunk = () => fn();
     thunk.__THUNK__ = exports.THUNK_SYMBOL;
     return thunk;
 };
 exports.toThunk = toThunk;
-var trampoline = function (fn) {
-    var cont = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return (0, exports.toThunk)(function () { return fn.apply(void 0, __spreadArray([], __read(args), false)); });
-    };
-    return Object.assign(function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var result = fn.apply(void 0, __spreadArray([], __read(args), false));
+const trampoline = (fn) => {
+    const cont = (...args) => (0, exports.toThunk)(() => fn(...args));
+    return Object.assign((...args) => {
+        let result = fn(...args);
         while ((0, exports.isThunk)(result) && typeof result === 'function') {
             result = result();
         }
         return result;
-    }, { cont: cont });
+    }, { cont });
 };
 exports.trampoline = trampoline;
-var trampolineAsync = function (fn) {
-    var cont = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return (0, exports.toThunk)(function () { return fn.apply(void 0, __spreadArray([], __read(args), false)); });
-    };
-    return Object.assign(function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
+const trampolineAsync = (fn) => {
+    const cont = (...args) => (0, exports.toThunk)(() => fn(...args));
+    return Object.assign((...args) => __awaiter(void 0, void 0, void 0, function* () {
+        let result = yield fn(...args);
+        while ((0, exports.isThunk)(result) && typeof result === 'function') {
+            result = yield result();
         }
-        return __awaiter(void 0, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, fn.apply(void 0, __spreadArray([], __read(args), false))];
-                    case 1:
-                        result = _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        if (!((0, exports.isThunk)(result) && typeof result === 'function')) return [3 /*break*/, 4];
-                        return [4 /*yield*/, result()];
-                    case 3:
-                        result = _a.sent();
-                        return [3 /*break*/, 2];
-                    case 4: return [2 /*return*/, result];
-                }
-            });
-        });
-    }, { cont: cont });
+        return result;
+    }), { cont });
 };
 exports.trampolineAsync = trampolineAsync;

package/dist/utils/validate-type.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNumber = exports.isObjectWithNumberId = exports.isObjectWithNonNumberId = exports.isObjectWithoutId = exports.isNonNumberNonObjectButDefined = exports.parseBySchema = exports.binaryTreeNodeValWithId = exports.objectWithNumberIdSchema = exports.objectWithNonNumberIdSchema = exports.keyValueObjectWithIdSchema = exports.objectWithoutIdSchema = exports.keyValueObjectSchema = exports.nonNumberNonObjectButDefinedSchema = void 0;
-var zod_1 = require("zod");
+const zod_1 = require("zod");
 exports.nonNumberNonObjectButDefinedSchema = zod_1.z.union([zod_1.z.string(),
     zod_1.z.boolean(), zod_1.z.any()])
     .nullable();
 exports.keyValueObjectSchema = zod_1.z.record(zod_1.z.unknown());
-exports.objectWithoutIdSchema = exports.keyValueObjectSchema.refine(function (obj) { return !('id' in obj); }, {
+exports.objectWithoutIdSchema = exports.keyValueObjectSchema.refine(obj => !('id' in obj), {
     message: 'Object cannot contain the \'id\' field',
 });
 exports.keyValueObjectWithIdSchema = zod_1.z.record(zod_1.z.any()).and(zod_1.z.object({