data-structure-typed 2.2.7 → 2.3.0

package/dist/leetcode/hash-map.mjs

@@ -0,0 +1,493 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var IterableEntryBase = class {
+  static {
+    __name(this, "IterableEntryBase");
+  }
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  *entries() {
+    for (const item of this) {
+      yield item;
+    }
+  }
+  *keys() {
+    for (const item of this) {
+      yield item[0];
+    }
+  }
+  *values() {
+    for (const item of this) {
+      yield item[1];
+    }
+  }
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      callbackfn.call(thisArg, value, key, index++, this);
+    }
+  }
+  find(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
+    }
+    return;
+  }
+  has(key) {
+    for (const item of this) {
+      const [itemKey] = item;
+      if (itemKey === key) return true;
+    }
+    return false;
+  }
+  hasValue(value) {
+    for (const [, elementValue] of this) {
+      if (elementValue === value) return true;
+    }
+    return false;
+  }
+  get(key) {
+    for (const item of this) {
+      const [itemKey, value] = item;
+      if (itemKey === key) return value;
+    }
+    return;
+  }
+  reduce(callbackfn, initialValue) {
+    let accumulator = initialValue;
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      accumulator = callbackfn(accumulator, value, key, index++, this);
+    }
+    return accumulator;
+  }
+  toArray() {
+    return [...this];
+  }
+  toVisual() {
+    return [...this];
+  }
+  print() {
+    console.log(this.toVisual());
+  }
+};
+var rangeCheck =  __name((index, min, max, message = "Index out of bounds.") => {
+  if (index < min || index > max) throw new RangeError(message);
+}, "rangeCheck");
+var isWeakKey =  __name((input) => {
+  const inputType = typeof input;
+  return inputType === "object" && input !== null || inputType === "function";
+}, "isWeakKey");
+var HashMap = class extends IterableEntryBase {
+  static {
+    __name(this, "HashMap");
+  }
+  constructor(entryOrRawElements = [], options) {
+    super();
+    if (options) {
+      const { hashFn, toEntryFn } = options;
+      if (hashFn) this._hashFn = hashFn;
+      if (toEntryFn) this._toEntryFn = toEntryFn;
+    }
+    if (entryOrRawElements) this.setMany(entryOrRawElements);
+  }
+  _store = {};
+  get store() {
+    return this._store;
+  }
+  _objMap =  new Map();
+  get objMap() {
+    return this._objMap;
+  }
+  _toEntryFn;
+  get toEntryFn() {
+    return this._toEntryFn;
+  }
+  _size = 0;
+  get size() {
+    return this._size;
+  }
+  _hashFn =  __name((key) => String(key), "_hashFn");
+  get hashFn() {
+    return this._hashFn;
+  }
+  isEmpty() {
+    return this._size === 0;
+  }
+  clear() {
+    this._store = {};
+    this._objMap.clear();
+    this._size = 0;
+  }
+  isEntry(rawElement) {
+    return Array.isArray(rawElement) && rawElement.length === 2;
+  }
+  set(key, value) {
+    if (this._isObjKey(key)) {
+      if (!this.objMap.has(key)) this._size++;
+      this.objMap.set(key, value);
+    } else {
+      const strKey = this._getNoObjKey(key);
+      if (this.store[strKey] === void 0) this._size++;
+      this._store[strKey] = { key, value };
+    }
+    return true;
+  }
+  setMany(entryOrRawElements) {
+    const results = [];
+    for (const rawEle of entryOrRawElements) {
+      let key, value;
+      if (this.isEntry(rawEle)) [key, value] = rawEle;
+      else if (this._toEntryFn) [key, value] = this._toEntryFn(rawEle);
+      if (key !== void 0 && value !== void 0) results.push(this.set(key, value));
+    }
+    return results;
+  }
+  get(key) {
+    if (this._isObjKey(key)) return this.objMap.get(key);
+    const strKey = this._getNoObjKey(key);
+    return this._store[strKey]?.value;
+  }
+  has(key) {
+    if (this._isObjKey(key)) return this.objMap.has(key);
+    const strKey = this._getNoObjKey(key);
+    return strKey in this.store;
+  }
+  delete(key) {
+    if (this._isObjKey(key)) {
+      if (this.objMap.has(key)) this._size--;
+      return this.objMap.delete(key);
+    }
+    const strKey = this._getNoObjKey(key);
+    if (strKey in this.store) {
+      delete this.store[strKey];
+      this._size--;
+      return true;
+    }
+    return false;
+  }
+  setHashFn(fn) {
+    if (this._hashFn === fn) return this;
+    this._hashFn = fn;
+    this._rehashNoObj();
+    return this;
+  }
+  clone() {
+    const opts = { hashFn: this._hashFn, toEntryFn: this._toEntryFn };
+    return this._createLike(this, opts);
+  }
+  map(callbackfn, thisArg) {
+    const out = this._createLike();
+    let index = 0;
+    for (const [key, value] of this) out.set(key, callbackfn.call(thisArg, value, key, index++, this));
+    return out;
+  }
+  filter(predicate, thisArg) {
+    const out = this._createLike();
+    let index = 0;
+    for (const [key, value] of this) if (predicate.call(thisArg, value, key, index++, this)) out.set(key, value);
+    return out;
+  }
+  _createLike(entries = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(entries, options);
+  }
+  _rehashNoObj() {
+    const fresh = {};
+    for (const { key, value } of Object.values(this._store)) {
+      const sk = this._getNoObjKey(key);
+      fresh[sk] = { key, value };
+    }
+    this._store = fresh;
+  }
+  *_getIterator() {
+    for (const node of Object.values(this.store)) yield [node.key, node.value];
+    for (const node of this.objMap) yield node;
+  }
+  _isObjKey(key) {
+    const keyType = typeof key;
+    return (keyType === "object" || keyType === "function") && key !== null;
+  }
+  _getNoObjKey(key) {
+    const keyType = typeof key;
+    let strKey;
+    if (keyType !== "string" && keyType !== "number" && keyType !== "symbol") {
+      strKey = this._hashFn(key);
+    } else {
+      if (keyType === "number") {
+        strKey = key;
+      } else {
+        strKey = key;
+      }
+    }
+    return strKey;
+  }
+};
+var LinkedHashMap = class extends IterableEntryBase {
+  static {
+    __name(this, "LinkedHashMap");
+  }
+  _sentinel;
+  constructor(entryOrRawElements = [], options) {
+    super();
+    this._sentinel = {};
+    this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
+    if (options) {
+      const { hashFn, objHashFn, toEntryFn } = options;
+      if (hashFn) this._hashFn = hashFn;
+      if (objHashFn) this._objHashFn = objHashFn;
+      if (toEntryFn) this._toEntryFn = toEntryFn;
+    }
+    if (entryOrRawElements) this.setMany(entryOrRawElements);
+  }
+  _hashFn =  __name((key) => String(key), "_hashFn");
+  get hashFn() {
+    return this._hashFn;
+  }
+  _objHashFn =  __name((key) => key, "_objHashFn");
+  get objHashFn() {
+    return this._objHashFn;
+  }
+  _noObjMap = {};
+  get noObjMap() {
+    return this._noObjMap;
+  }
+  _objMap =  new WeakMap();
+  get objMap() {
+    return this._objMap;
+  }
+  _head;
+  get head() {
+    return this._head;
+  }
+  _tail;
+  get tail() {
+    return this._tail;
+  }
+  _toEntryFn =  __name((rawElement) => {
+    if (this.isEntry(rawElement)) {
+      return rawElement;
+    }
+    throw new Error(
+      "If `entryOrRawElements` does not adhere to [key,value], provide `options.toEntryFn` to transform raw records."
+    );
+  }, "_toEntryFn");
+  get toEntryFn() {
+    return this._toEntryFn;
+  }
+  _size = 0;
+  get size() {
+    return this._size;
+  }
+  get first() {
+    if (this._size === 0) return;
+    return [this.head.key, this.head.value];
+  }
+  get last() {
+    if (this._size === 0) return;
+    return [this.tail.key, this.tail.value];
+  }
+  *begin() {
+    let node = this.head;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.next;
+    }
+  }
+  *reverseBegin() {
+    let node = this.tail;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.prev;
+    }
+  }
+  set(key, value) {
+    let node;
+    const isNewKey = !this.has(key);
+    if (isWeakKey(key)) {
+      const hash = this._objHashFn(key);
+      node = this.objMap.get(hash);
+      if (!node && isNewKey) {
+        node = { key: hash, value, prev: this.tail, next: this._sentinel };
+        this.objMap.set(hash, node);
+      } else if (node) {
+        node.value = value;
+      }
+    } else {
+      const hash = this._hashFn(key);
+      node = this.noObjMap[hash];
+      if (!node && isNewKey) {
+        this.noObjMap[hash] = node = { key, value, prev: this.tail, next: this._sentinel };
+      } else if (node) {
+        node.value = value;
+      }
+    }
+    if (node && isNewKey) {
+      if (this._size === 0) {
+        this._head = node;
+        this._sentinel.next = node;
+      } else {
+        this.tail.next = node;
+        node.prev = this.tail;
+      }
+      this._tail = node;
+      this._sentinel.prev = node;
+      this._size++;
+    }
+    return true;
+  }
+  setMany(entryOrRawElements) {
+    const results = [];
+    for (const rawEle of entryOrRawElements) {
+      let key, value;
+      if (this.isEntry(rawEle)) [key, value] = rawEle;
+      else if (this._toEntryFn) [key, value] = this._toEntryFn(rawEle);
+      if (key !== void 0 && value !== void 0) results.push(this.set(key, value));
+    }
+    return results;
+  }
+  has(key) {
+    if (isWeakKey(key)) {
+      const hash2 = this._objHashFn(key);
+      return this.objMap.has(hash2);
+    }
+    const hash = this._hashFn(key);
+    return hash in this.noObjMap;
+  }
+  get(key) {
+    if (isWeakKey(key)) {
+      const hash2 = this._objHashFn(key);
+      const node2 = this.objMap.get(hash2);
+      return node2 ? node2.value : void 0;
+    }
+    const hash = this._hashFn(key);
+    const node = this.noObjMap[hash];
+    return node ? node.value : void 0;
+  }
+  at(index) {
+    rangeCheck(index, 0, this._size - 1);
+    let node = this.head;
+    while (index--) node = node.next;
+    return node.value;
+  }
+  delete(key) {
+    let node;
+    if (isWeakKey(key)) {
+      const hash = this._objHashFn(key);
+      node = this.objMap.get(hash);
+      if (!node) return false;
+      this.objMap.delete(hash);
+    } else {
+      const hash = this._hashFn(key);
+      node = this.noObjMap[hash];
+      if (!node) return false;
+      delete this.noObjMap[hash];
+    }
+    return this._deleteNode(node);
+  }
+  deleteWhere(predicate) {
+    let node = this._head;
+    let i = 0;
+    while (node !== this._sentinel) {
+      const cur = node;
+      node = node.next;
+      if (predicate(cur.key, cur.value, i++, this)) {
+        if (isWeakKey(cur.key)) {
+          this._objMap.delete(cur.key);
+        } else {
+          const hash = this._hashFn(cur.key);
+          delete this._noObjMap[hash];
+        }
+        return this._deleteNode(cur);
+      }
+    }
+    return false;
+  }
+  deleteAt(index) {
+    rangeCheck(index, 0, this._size - 1);
+    let node = this.head;
+    while (index--) node = node.next;
+    return this._deleteNode(node);
+  }
+  isEmpty() {
+    return this._size === 0;
+  }
+  isEntry(rawElement) {
+    return Array.isArray(rawElement) && rawElement.length === 2;
+  }
+  clear() {
+    this._noObjMap = {};
+    this._size = 0;
+    this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
+  }
+  clone() {
+    const opts = { hashFn: this._hashFn, objHashFn: this._objHashFn };
+    return this._createLike(this, opts);
+  }
+  filter(predicate, thisArg) {
+    const out = this._createLike();
+    let index = 0;
+    for (const [key, value] of this) {
+      if (predicate.call(thisArg, value, key, index, this)) out.set(key, value);
+      index++;
+    }
+    return out;
+  }
+  map(callback, thisArg) {
+    const out = this._createLike();
+    let index = 0;
+    for (const [key, value] of this) {
+      const [newKey, newValue] = callback.call(thisArg, value, key, index, this);
+      out.set(newKey, newValue);
+      index++;
+    }
+    return out;
+  }
+  *_getIterator() {
+    let node = this.head;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.next;
+    }
+  }
+  _deleteNode(node) {
+    const { prev, next } = node;
+    prev.next = next;
+    next.prev = prev;
+    if (node === this.head) this._head = next;
+    if (node === this.tail) this._tail = prev;
+    this._size -= 1;
+    return true;
+  }
+  _createLike(entries = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(entries, options);
+  }
+};
+export {
+  HashMap,
+  LinkedHashMap
+};