data-structure-typed 2.5.0 → 2.5.1

package/dist/leetcode/trie.mjs

@@ -1,413 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var IterableElementBase = class {
-  static {
-    __name(this, "IterableElementBase");
-  }
-  constructor(options) {
-    if (options) {
-      const { toElementFn } = options;
-      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
-    }
-  }
-  _toElementFn;
-  get toElementFn() {
-    return this._toElementFn;
-  }
-  *[Symbol.iterator](...args) {
-    yield* this._getIterator(...args);
-  }
-  *values() {
-    for (const item of this) yield item;
-  }
-  every(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (thisArg === void 0) {
-        if (!predicate(item, index++, this)) return false;
-      } else {
-        const fn = predicate;
-        if (!fn.call(thisArg, item, index++, this)) return false;
-      }
-    }
-    return true;
-  }
-  some(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (thisArg === void 0) {
-        if (predicate(item, index++, this)) return true;
-      } else {
-        const fn = predicate;
-        if (fn.call(thisArg, item, index++, this)) return true;
-      }
-    }
-    return false;
-  }
-  forEach(callbackfn, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (thisArg === void 0) {
-        callbackfn(item, index++, this);
-      } else {
-        const fn = callbackfn;
-        fn.call(thisArg, item, index++, this);
-      }
-    }
-  }
-  find(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (thisArg === void 0) {
-        if (predicate(item, index++, this)) return item;
-      } else {
-        const fn = predicate;
-        if (fn.call(thisArg, item, index++, this)) return item;
-      }
-    }
-    return;
-  }
-  has(element) {
-    for (const ele of this) if (ele === element) return true;
-    return false;
-  }
-  reduce(callbackfn, initialValue) {
-    let index = 0;
-    const iter = this[Symbol.iterator]();
-    let acc;
-    if (arguments.length >= 2) {
-      acc = initialValue;
-    } else {
-      const first = iter.next();
-      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
-      acc = first.value;
-      index = 1;
-    }
-    for (const value of iter) {
-      acc = callbackfn(acc, value, index++, this);
-    }
-    return acc;
-  }
-  toArray() {
-    return [...this];
-  }
-  toVisual() {
-    return [...this];
-  }
-  print() {
-    console.log(this.toVisual());
-  }
-};
-var TrieNode = class {
-  static {
-    __name(this, "TrieNode");
-  }
-  constructor(key) {
-    this._key = key;
-    this._isEnd = false;
-    this._children =  new Map();
-  }
-  _key;
-  get key() {
-    return this._key;
-  }
-  set key(value) {
-    this._key = value;
-  }
-  _children;
-  get children() {
-    return this._children;
-  }
-  set children(value) {
-    this._children = value;
-  }
-  _isEnd;
-  get isEnd() {
-    return this._isEnd;
-  }
-  set isEnd(value) {
-    this._isEnd = value;
-  }
-};
-var Trie = class extends IterableElementBase {
-  static {
-    __name(this, "Trie");
-  }
-  constructor(words = [], options) {
-    super(options);
-    if (options) {
-      const { caseSensitive } = options;
-      if (caseSensitive !== void 0) this._caseSensitive = caseSensitive;
-    }
-    if (words) {
-      this.addMany(words);
-    }
-  }
-  _size = 0;
-  get size() {
-    return this._size;
-  }
-  _caseSensitive = true;
-  get caseSensitive() {
-    return this._caseSensitive;
-  }
-  _root = new TrieNode("");
-  get root() {
-    return this._root;
-  }
-  get _total() {
-    return this._size;
-  }
-  add(word) {
-    word = this._caseProcess(word);
-    let cur = this.root;
-    let isNewWord = false;
-    for (const c of word) {
-      let nodeC = cur.children.get(c);
-      if (!nodeC) {
-        nodeC = new TrieNode(c);
-        cur.children.set(c, nodeC);
-      }
-      cur = nodeC;
-    }
-    if (!cur.isEnd) {
-      isNewWord = true;
-      cur.isEnd = true;
-      this._size++;
-    }
-    return isNewWord;
-  }
-  addMany(words) {
-    const ans = [];
-    for (const word of words) {
-      if (this.toElementFn) {
-        ans.push(this.add(this.toElementFn(word)));
-      } else {
-        ans.push(this.add(word));
-      }
-    }
-    return ans;
-  }
-  has(word) {
-    word = this._caseProcess(word);
-    let cur = this.root;
-    for (const c of word) {
-      const nodeC = cur.children.get(c);
-      if (!nodeC) return false;
-      cur = nodeC;
-    }
-    return cur.isEnd;
-  }
-  isEmpty() {
-    return this._size === 0;
-  }
-  clear() {
-    this._size = 0;
-    this._root = new TrieNode("");
-  }
-  delete(word) {
-    word = this._caseProcess(word);
-    let isDeleted = false;
-    const dfs =  __name((cur, i) => {
-      const char = word[i];
-      const child = cur.children.get(char);
-      if (child) {
-        if (i === word.length - 1) {
-          if (child.isEnd) {
-            if (child.children.size > 0) {
-              child.isEnd = false;
-            } else {
-              cur.children.delete(char);
-            }
-            isDeleted = true;
-            return true;
-          }
-          return false;
-        }
-        const res = dfs(child, i + 1);
-        if (res && !cur.isEnd && child.children.size === 0) {
-          cur.children.delete(char);
-          return true;
-        }
-        return false;
-      }
-      return false;
-    }, "dfs");
-    dfs(this.root, 0);
-    if (isDeleted) {
-      this._size--;
-    }
-    return isDeleted;
-  }
-  getHeight() {
-    const startNode = this.root;
-    let maxDepth = 0;
-    if (startNode) {
-      const bfs =  __name((node, level) => {
-        if (level > maxDepth) {
-          maxDepth = level;
-        }
-        const { children } = node;
-        if (children) {
-          for (const child of children.entries()) {
-            bfs(child[1], level + 1);
-          }
-        }
-      }, "bfs");
-      bfs(startNode, 0);
-    }
-    return maxDepth;
-  }
-  hasPurePrefix(input) {
-    input = this._caseProcess(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;
-  }
-  hasPrefix(input) {
-    input = this._caseProcess(input);
-    let cur = this.root;
-    for (const c of input) {
-      const nodeC = cur.children.get(c);
-      if (!nodeC) return false;
-      cur = nodeC;
-    }
-    return true;
-  }
-  hasCommonPrefix(input) {
-    input = this._caseProcess(input);
-    let commonPre = "";
-    const dfs =  __name((cur) => {
-      commonPre += cur.key;
-      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");
-    dfs(this.root);
-    return commonPre === input;
-  }
-  getLongestCommonPrefix() {
-    let commonPre = "";
-    const dfs =  __name((cur) => {
-      commonPre += cur.key;
-      if (cur.isEnd) return;
-      if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
-      else return;
-    }, "dfs");
-    dfs(this.root);
-    return commonPre;
-  }
-  getWords(prefix = "", max = Number.MAX_SAFE_INTEGER, isAllWhenEmptyPrefix = false) {
-    prefix = this._caseProcess(prefix);
-    const words = [];
-    let found = 0;
-    function dfs(node, word) {
-      for (const char of node.children.keys()) {
-        const charNode = node.children.get(char);
-        if (charNode !== void 0) {
-          dfs(charNode, word.concat(char));
-        }
-      }
-      if (node.isEnd) {
-        if (found > max - 1) return;
-        words.push(word);
-        found++;
-      }
-    }
-    __name(dfs, "dfs");
-    let startNode = this.root;
-    if (prefix) {
-      for (const c of prefix) {
-        const nodeC = startNode.children.get(c);
-        if (nodeC) {
-          startNode = nodeC;
-        } else {
-          return [];
-        }
-      }
-    }
-    if (isAllWhenEmptyPrefix || startNode !== this.root) dfs(startNode, prefix);
-    return words;
-  }
-  clone() {
-    const next = this._createInstance();
-    for (const x of this) next.add(x);
-    return next;
-  }
-  filter(predicate, thisArg) {
-    const results = this._createInstance();
-    let index = 0;
-    for (const word of this) {
-      if (predicate.call(thisArg, word, index, this)) {
-        results.add(word);
-      }
-      index++;
-    }
-    return results;
-  }
-  map(callback, options, thisArg) {
-    const newTrie = this._createLike([], options);
-    let i = 0;
-    for (const x of this) {
-      const v = thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
-      if (typeof v !== "string") {
-        throw new TypeError(`Trie.map callback must return string; got ${typeof v}`);
-      }
-      newTrie.add(v);
-    }
-    return newTrie;
-  }
-  mapSame(callback, thisArg) {
-    const next = this._createInstance();
-    let i = 0;
-    for (const key of this) {
-      const mapped = thisArg === void 0 ? callback(key, i++, this) : callback.call(thisArg, key, i++, this);
-      next.add(mapped);
-    }
-    return next;
-  }
-  _createInstance(options) {
-    const Ctor = this.constructor;
-    const next = new Ctor([], {
-      toElementFn: this.toElementFn,
-      caseSensitive: this.caseSensitive,
-      ...options ?? {}
-    });
-    return next;
-  }
-  _createLike(elements = [], options) {
-    const Ctor = this.constructor;
-    return new Ctor(elements, options);
-  }
-  _spawnLike(options) {
-    return this._createLike([], options);
-  }
-  *_getIterator() {
-    function* _dfs(node, path) {
-      if (node.isEnd) {
-        yield path;
-      }
-      for (const [char, childNode] of node.children) {
-        yield* _dfs(childNode, path + char);
-      }
-    }
-    __name(_dfs, "_dfs");
-    yield* _dfs(this.root, "");
-  }
-  _caseProcess(str) {
-    if (!this._caseSensitive) {
-      str = str.toLowerCase();
-    }
-    return str;
-  }
-};
-export {
-  Trie,
-  TrieNode
-};