stack-typed 2.1.1 → 2.1.2

package/dist/umd/stack-typed.js

@@ -0,0 +1,563 @@
+"use strict";
+var stackTyped = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    DFSOperation: () => DFSOperation,
+    Range: () => Range,
+    Stack: () => Stack
+  });
+
+  // src/data-structures/base/iterable-element-base.ts
+  var IterableElementBase = class {
+    /**
+     * Create a new iterable base.
+     *
+     * @param options Optional behavior overrides. When provided, a `toElementFn`
+     * is used to convert a raw element (`R`) into a public element (`E`).
+     *
+     * @remarks
+     * Time O(1), Space O(1).
+     */
+    constructor(options) {
+      /**
+       * The converter used to transform a raw element (`R`) into a public element (`E`).
+       *
+       * @remarks
+       * Time O(1), Space O(1).
+       */
+      __publicField(this, "_toElementFn");
+      if (options) {
+        const { toElementFn } = options;
+        if (typeof toElementFn === "function") this._toElementFn = toElementFn;
+        else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+      }
+    }
+    /**
+     * Exposes the current `toElementFn`, if configured.
+     *
+     * @returns The converter function or `undefined` when not set.
+     * @remarks
+     * Time O(1), Space O(1).
+     */
+    get toElementFn() {
+      return this._toElementFn;
+    }
+    /**
+     * Returns an iterator over the structure's elements.
+     *
+     * @param args Optional iterator arguments forwarded to the internal iterator.
+     * @returns An `IterableIterator<E>` that yields the elements in traversal order.
+     *
+     * @remarks
+     * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.
+     */
+    *[Symbol.iterator](...args) {
+      yield* this._getIterator(...args);
+    }
+    /**
+     * Returns an iterator over the values (alias of the default iterator).
+     *
+     * @returns An `IterableIterator<E>` over all elements.
+     * @remarks
+     * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).
+     */
+    *values() {
+      for (const item of this) yield item;
+    }
+    /**
+     * Tests whether all elements satisfy the predicate.
+     *
+     * @template TReturn
+     * @param predicate Function invoked for each element with signature `(value, index, self)`.
+     * @param thisArg Optional `this` binding for the predicate.
+     * @returns `true` if every element passes; otherwise `false`.
+     *
+     * @remarks
+     * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).
+     */
+    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;
+    }
+    /**
+     * Tests whether at least one element satisfies the predicate.
+     *
+     * @param predicate Function invoked for each element with signature `(value, index, self)`.
+     * @param thisArg Optional `this` binding for the predicate.
+     * @returns `true` if any element passes; otherwise `false`.
+     *
+     * @remarks
+     * Time O(n) in the worst case; may exit early on first success. Space O(1).
+     */
+    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;
+    }
+    /**
+     * Invokes a callback for each element in iteration order.
+     *
+     * @param callbackfn Function invoked per element with signature `(value, index, self)`.
+     * @param thisArg Optional `this` binding for the callback.
+     * @returns `void`.
+     *
+     * @remarks
+     * Time O(n), Space O(1).
+     */
+    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);
+        }
+      }
+    }
+    // Implementation signature
+    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;
+    }
+    /**
+     * Checks whether a strictly-equal element exists in the structure.
+     *
+     * @param element The element to test with `===` equality.
+     * @returns `true` if an equal element is found; otherwise `false`.
+     *
+     * @remarks
+     * Time O(n) in the worst case. Space O(1).
+     */
+    has(element) {
+      for (const ele of this) if (ele === element) return true;
+      return false;
+    }
+    /**
+     * Reduces all elements to a single accumulated value.
+     *
+     * @overload
+     * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`. The first element is used as the initial accumulator.
+     * @returns The final accumulated value typed as `E`.
+     *
+     * @overload
+     * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`.
+     * @param initialValue The initial accumulator value of type `E`.
+     * @returns The final accumulated value typed as `E`.
+     *
+     * @overload
+     * @template U The accumulator type when it differs from `E`.
+     * @param callbackfn Reducer of signature `(acc: U, value, index, self) => U`.
+     * @param initialValue The initial accumulator value of type `U`.
+     * @returns The final accumulated value typed as `U`.
+     *
+     * @remarks
+     * Time O(n), Space O(1). Throws if called on an empty structure without `initialValue`.
+     */
+    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;
+    }
+    /**
+     * Materializes the elements into a new array.
+     *
+     * @returns A shallow array copy of the iteration order.
+     * @remarks
+     * Time O(n), Space O(n).
+     */
+    toArray() {
+      return [...this];
+    }
+    /**
+     * Returns a representation of the structure suitable for quick visualization.
+     * Defaults to an array of elements; subclasses may override to provide richer visuals.
+     *
+     * @returns A visual representation (array by default).
+     * @remarks
+     * Time O(n), Space O(n).
+     */
+    toVisual() {
+      return [...this];
+    }
+    /**
+     * Prints `toVisual()` to the console. Intended for quick debugging.
+     *
+     * @returns `void`.
+     * @remarks
+     * Time O(n) due to materialization, Space O(n) for the intermediate representation.
+     */
+    print() {
+      console.log(this.toVisual());
+    }
+  };
+
+  // src/data-structures/stack/stack.ts
+  var Stack = class extends IterableElementBase {
+    /**
+     * Create a Stack and optionally bulk-push elements.
+     * @remarks Time O(N), Space O(N)
+     * @param [elements] - Iterable of elements (or raw records if toElementFn is set).
+     * @param [options] - Options such as toElementFn and equality function.
+     * @returns New Stack instance.
+     */
+    constructor(elements = [], options) {
+      super(options);
+      __publicField(this, "_equals", Object.is);
+      __publicField(this, "_elements", []);
+      this.pushMany(elements);
+    }
+    /**
+     * Get the backing array of elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns Internal elements array.
+     */
+    get elements() {
+      return this._elements;
+    }
+    /**
+     * Get the number of stored elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns Current size.
+     */
+    get size() {
+      return this.elements.length;
+    }
+    /**
+     * Create a stack from an array of elements.
+     * @remarks Time O(N), Space O(N)
+     * @template E
+     * @template R
+     * @param this - The constructor (subclass) to instantiate.
+     * @param elements - Array of elements to push in order.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A new Stack populated from the array.
+     */
+    static fromArray(elements, options) {
+      return new this(elements, options);
+    }
+    /**
+     * Check whether the stack is empty.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if size is 0.
+     */
+    isEmpty() {
+      return this.elements.length === 0;
+    }
+    /**
+     * Get the top element without removing it.
+     * @remarks Time O(1), Space O(1)
+     * @returns Top element or undefined.
+     */
+    peek() {
+      return this.isEmpty() ? void 0 : this.elements[this.elements.length - 1];
+    }
+    /**
+     * Push one element onto the top.
+     * @remarks Time O(1), Space O(1)
+     * @param element - Element to push.
+     * @returns True when pushed.
+     */
+    push(element) {
+      this.elements.push(element);
+      return true;
+    }
+    /**
+     * Pop and return the top element.
+     * @remarks Time O(1), Space O(1)
+     * @returns Removed element or undefined.
+     */
+    pop() {
+      return this.isEmpty() ? void 0 : this.elements.pop();
+    }
+    /**
+     * Push many elements from an iterable.
+     * @remarks Time O(N), Space O(1)
+     * @param elements - Iterable of elements (or raw records if toElementFn is set).
+     * @returns Array of per-element success flags.
+     */
+    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 the first occurrence of a specific element.
+     * @remarks Time O(N), Space O(1)
+     * @param element - Element to remove (using the configured equality).
+     * @returns True if an element was removed.
+     */
+    delete(element) {
+      const idx = this._indexOfByEquals(element);
+      return this.deleteAt(idx);
+    }
+    /**
+     * Delete the element at an index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index from the bottom.
+     * @returns True if removed.
+     */
+    deleteAt(index) {
+      if (index < 0 || index >= this.elements.length) return false;
+      const spliced = this.elements.splice(index, 1);
+      return spliced.length === 1;
+    }
+    /**
+     * Delete the first element that satisfies a predicate.
+     * @remarks Time O(N), Space O(1)
+     * @param predicate - Function (value, index, stack) → boolean to decide deletion.
+     * @returns True if a match was removed.
+     */
+    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;
+    }
+    /**
+     * Remove all elements and reset storage.
+     * @remarks Time O(1), Space O(1)
+     * @returns void
+     */
+    clear() {
+      this._elements = [];
+    }
+    /**
+     * Deep clone this stack.
+     * @remarks Time O(N), Space O(N)
+     * @returns A new stack with the same content.
+     */
+    clone() {
+      const out = this._createInstance({ toElementFn: this.toElementFn });
+      for (const v of this) out.push(v);
+      return out;
+    }
+    /**
+     * Filter elements into a new stack of the same class.
+     * @remarks Time O(N), Space O(N)
+     * @param predicate - Predicate (value, index, stack) → boolean to keep value.
+     * @param [thisArg] - Value for `this` inside the predicate.
+     * @returns A new stack with kept values.
+     */
+    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;
+    }
+    /**
+     * Map values into a new stack of the same element type.
+     * @remarks Time O(N), Space O(N)
+     * @param callback - Mapping function (value, index, stack) → newValue.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new stack with mapped values.
+     */
+    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 values into a new stack (possibly different element type).
+     * @remarks Time O(N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param callback - Mapping function (value, index, stack) → newElement.
+     * @param [options] - Options for the output stack (e.g., toElementFn).
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new Stack with mapped elements.
+     */
+    map(callback, options, thisArg) {
+      const out = this._createLike([], { ...options != null ? 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;
+    }
+    /**
+     * Set the equality comparator used by delete/search operations.
+     * @remarks Time O(1), Space O(1)
+     * @param equals - Equality predicate (a, b) → boolean.
+     * @returns This stack.
+     */
+    setEquality(equals) {
+      this._equals = equals;
+      return this;
+    }
+    /**
+     * (Protected) Find the index of a target element using the equality function.
+     * @remarks Time O(N), Space O(1)
+     * @param target - Element to search for.
+     * @returns Index or -1 if not found.
+     */
+    _indexOfByEquals(target) {
+      for (let i = 0; i < this.elements.length; i++) if (this._equals(this.elements[i], target)) return i;
+      return -1;
+    }
+    /**
+     * (Protected) Create an empty instance of the same concrete class.
+     * @remarks Time O(1), Space O(1)
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind stack instance.
+     */
+    _createInstance(options) {
+      const Ctor = this.constructor;
+      return new Ctor([], options);
+    }
+    /**
+     * (Protected) Create a like-kind stack and seed it from an iterable.
+     * @remarks Time O(N), Space O(N)
+     * @template T
+     * @template RR
+     * @param [elements] - Iterable used to seed the new stack.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A like-kind Stack instance.
+     */
+    _createLike(elements = [], options) {
+      const Ctor = this.constructor;
+      return new Ctor(elements, options);
+    }
+    /**
+     * (Protected) Iterate elements from bottom to top.
+     * @remarks Time O(N), Space O(1)
+     * @returns Iterator of elements.
+     */
+    *_getIterator() {
+      for (let i = 0; i < this.elements.length; i++) yield this.elements[i];
+    }
+  };
+
+  // src/utils/utils.ts
+  function isPrimitiveComparable(value) {
+    const valueType = typeof value;
+    if (valueType === "number") return true;
+    return valueType === "bigint" || valueType === "string" || valueType === "boolean";
+  }
+  function tryObjectToPrimitive(obj) {
+    if (typeof obj.valueOf === "function") {
+      const valueOfResult = obj.valueOf();
+      if (valueOfResult !== obj) {
+        if (isPrimitiveComparable(valueOfResult)) return valueOfResult;
+        if (typeof valueOfResult === "object" && valueOfResult !== null) return tryObjectToPrimitive(valueOfResult);
+      }
+    }
+    if (typeof obj.toString === "function") {
+      const stringResult = obj.toString();
+      if (stringResult !== "[object Object]") return stringResult;
+    }
+    return null;
+  }
+  function isComparable(value, isForceObjectComparable = false) {
+    if (value === null || value === void 0) return false;
+    if (isPrimitiveComparable(value)) return true;
+    if (typeof value !== "object") return false;
+    if (value instanceof Date) return true;
+    if (isForceObjectComparable) return true;
+    const comparableValue = tryObjectToPrimitive(value);
+    if (comparableValue === null || comparableValue === void 0) return false;
+    return isPrimitiveComparable(comparableValue);
+  }
+
+  // src/common/index.ts
+  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+    return DFSOperation2;
+  })(DFSOperation || {});
+  var Range = class {
+    constructor(low, high, includeLow = true, includeHigh = true) {
+      this.low = low;
+      this.high = high;
+      this.includeLow = includeLow;
+      this.includeHigh = includeHigh;
+      if (!(isComparable(low) && isComparable(high))) throw new RangeError("low or high is not comparable");
+      if (low > high) throw new RangeError("low must be less than or equal to high");
+    }
+    // Determine whether a key is within the range
+    isInRange(key, comparator) {
+      const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+      const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+      return lowCheck && highCheck;
+    }
+  };
+  return __toCommonJS(src_exports);
+})();
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+//# sourceMappingURL=stack-typed.js.map