@thi.ng/associative/array-set.js

ES Map/Set-compatible implementations with customizable equality semantics & supporting operations

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __typeError = (msg) => {
  throw TypeError(msg);
};
var __decorateClass = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
  if (kind && result) __defProp(target, key, result);
  return result;
};
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
var _vals, _equiv;
import { SEMAPHORE } from "@thi.ng/api/api";
import { findIndex } from "@thi.ng/arrays/find";
import { equiv } from "@thi.ng/equiv";
import { dissoc } from "./dissoc.js";
import { __disposableValues } from "./internal/dispose.js";
import { __equivSet } from "./internal/equiv.js";
import { __tostringMixin } from "./internal/tostring.js";
import { into } from "./into.js";
let ArraySet = class extends Set {
  constructor(vals, opts = {}) {
    super();
    __privateAdd(this, _vals);
    __privateAdd(this, _equiv);
    __privateSet(this, _equiv, opts.equiv || equiv);
    __privateSet(this, _vals, []);
    vals && this.into(vals);
  }
  *[Symbol.iterator]() {
    yield* __privateGet(this, _vals);
  }
  // mixin
  [Symbol.dispose]() {
  }
  get [Symbol.species]() {
    return ArraySet;
  }
  get [Symbol.toStringTag]() {
    return "ArraySet";
  }
  get size() {
    return __privateGet(this, _vals).length;
  }
  copy() {
    const s = new ArraySet(null, { equiv: __privateGet(this, _equiv) });
    __privateSet(s, _vals, __privateGet(this, _vals).slice());
    return s;
  }
  empty() {
    return new ArraySet(null, this.opts());
  }
  clear() {
    __privateGet(this, _vals).length = 0;
  }
  first() {
    if (this.size) {
      return __privateGet(this, _vals)[0];
    }
  }
  add(key) {
    !this.has(key) && __privateGet(this, _vals).push(key);
    return this;
  }
  into(keys) {
    return into(this, keys);
  }
  has(key) {
    return this.get(key, SEMAPHORE) !== SEMAPHORE;
  }
  /**
   * Returns the canonical value for `x`, if present. If the set
   * contains no equivalent for `x`, returns `notFound`.
   *
   * @param key - search key
   * @param notFound - default value
   */
  get(key, notFound) {
    const i = findIndex(__privateGet(this, _vals), key, __privateGet(this, _equiv));
    return i >= 0 ? __privateGet(this, _vals)[i] : notFound;
  }
  delete(key) {
    const equiv2 = __privateGet(this, _equiv);
    const vals = __privateGet(this, _vals);
    for (let i = vals.length; i-- > 0; ) {
      if (equiv2(vals[i], key)) {
        vals.splice(i, 1);
        return true;
      }
    }
    return false;
  }
  disj(keys) {
    return dissoc(this, keys);
  }
  equiv(o) {
    return __equivSet(this, o);
  }
  /**
   * The value args given to the callback `fn` MUST be treated as
   * readonly/immutable. This could be enforced via TS, but would
   * break ES6 Set interface contract.
   *
   * @param fn -
   * @param thisArg -
   */
  forEach(fn, thisArg) {
    const vals = __privateGet(this, _vals);
    for (let i = vals.length; i-- > 0; ) {
      const v = vals[i];
      fn.call(thisArg, v, v, this);
    }
  }
  *entries() {
    for (const v of __privateGet(this, _vals)) {
      yield [v, v];
    }
  }
  *keys() {
    yield* __privateGet(this, _vals);
  }
  *values() {
    yield* __privateGet(this, _vals);
  }
  opts() {
    return { equiv: __privateGet(this, _equiv) };
  }
};
_vals = new WeakMap();
_equiv = new WeakMap();
ArraySet = __decorateClass([
  __disposableValues,
  __tostringMixin
], ArraySet);
const defArraySet = (vals, opts) => new ArraySet(vals, opts);
export {
  ArraySet,
  defArraySet
};