data-structure-typed 2.2.6 → 2.2.8

package/dist/leetcode/stack.mjs

@@ -0,0 +1,217 @@
+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 Stack = class extends IterableElementBase {
+  static {
+    __name(this, "Stack");
+  }
+  _equals = Object.is;
+  constructor(elements = [], options) {
+    super(options);
+    this.pushMany(elements);
+  }
+  _elements = [];
+  get elements() {
+    return this._elements;
+  }
+  get size() {
+    return this.elements.length;
+  }
+  static fromArray(elements, options) {
+    return new this(elements, options);
+  }
+  isEmpty() {
+    return this.elements.length === 0;
+  }
+  peek() {
+    return this.isEmpty() ? void 0 : this.elements[this.elements.length - 1];
+  }
+  push(element) {
+    this.elements.push(element);
+    return true;
+  }
+  pop() {
+    return this.isEmpty() ? void 0 : this.elements.pop();
+  }
+  pushMany(elements) {
+    const ans = [];
+    for (const el of elements) {
+      if (this.toElementFn) ans.push(this.push(this.toElementFn(el)));
+      else ans.push(this.push(el));
+    }
+    return ans;
+  }
+  delete(element) {
+    const idx = this._indexOfByEquals(element);
+    return this.deleteAt(idx);
+  }
+  deleteAt(index) {
+    if (index < 0 || index >= this.elements.length) return false;
+    const spliced = this.elements.splice(index, 1);
+    return spliced.length === 1;
+  }
+  deleteWhere(predicate) {
+    for (let i = 0; i < this.elements.length; i++) {
+      if (predicate(this.elements[i], i, this)) {
+        this.elements.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+  clear() {
+    this._elements = [];
+  }
+  clone() {
+    const out = this._createInstance({ toElementFn: this.toElementFn });
+    for (const v of this) out.push(v);
+    return out;
+  }
+  filter(predicate, thisArg) {
+    const out = this._createInstance({ toElementFn: this.toElementFn });
+    let index = 0;
+    for (const v of this) {
+      if (predicate.call(thisArg, v, index, this)) out.push(v);
+      index++;
+    }
+    return out;
+  }
+  mapSame(callback, thisArg) {
+    const out = this._createInstance({ toElementFn: this.toElementFn });
+    let index = 0;
+    for (const v of this) {
+      const mv = thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);
+      out.push(mv);
+    }
+    return out;
+  }
+  map(callback, options, thisArg) {
+    const out = this._createLike([], { ...options ?? {} });
+    let index = 0;
+    for (const v of this) {
+      out.push(thisArg === void 0 ? callback(v, index, this) : callback.call(thisArg, v, index, this));
+      index++;
+    }
+    return out;
+  }
+  setEquality(equals) {
+    this._equals = equals;
+    return this;
+  }
+  _indexOfByEquals(target) {
+    for (let i = 0; i < this.elements.length; i++) if (this._equals(this.elements[i], target)) return i;
+    return -1;
+  }
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], options);
+  }
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  *_getIterator() {
+    for (let i = 0; i < this.elements.length; i++) yield this.elements[i];
+  }
+};
+export {
+  Stack
+};