Collection of Weakrefs that can be iterated

WeakCollection.ts

class WeakCollection<T extends object> {
  #registry = new FinalizationRegistry((heldValue: WeakRef<T>) => {
    this.delete(heldValue);
  });
  #refs: WeakRef<T>[] = [];
  #values: T[] = [];

  #clean() {
    let index = 0;
    this.#values.length = 0;
    while (index < this.#refs.length) {
      const value = this.#refs[index].deref();
      if (value == undefined) {
        this.#deleteIdx(index);
      } else {
        this.#values.push(value);
        index++;
      }
    }
    return this.#values;
  }

  get values() {
    return this.#clean();
  }

  * [Symbol.iterator]() {
    const values = this.#clean();
    yield* values;
  };

  add(element: T) {
    const ref = new WeakRef(element);
    this.#refs.push(ref);
    this.#registry.register(element, ref);
  }

  delete(element: WeakRef<T>) {
    this.#registry.unregister(element);
    const value = element.deref();

    for (let i = 0; i < this.#refs.length; i++) {
      if (value === this.#refs[i].deref()) {
        this.#deleteIdx(i);
        return true;
      }
    }
    return false;
  }

  has(value: T) {
    for (const ref of this.#refs)
      if (ref.deref() === value)
        return true;

    return false;
  }

  #deleteIdx(idx: number) {
    if (this.#refs.length === 0) return;
    const lastIdx = this.#refs.length - 1;
    if (idx === lastIdx) {
      this.#refs.pop();
    } else {
      this.#refs[idx] = this.#refs[lastIdx]
      this.#refs.pop();
    }
  }
}

// @ts-ignore
window.WeakCollection = WeakCollection;

const obj = {x: {name: "hi"}, y: {name: "world"}, z: {name: "yooo"}};
const w = new WeakCollection();
w.add(obj.x);
w.add(obj.y);
w.add(obj.y);
w.add(obj.y);
w.add(obj.z);

// @ts-ignore
delete obj.x;
// @ts-ignore
delete obj.y;
// @ts-ignore
obj.z = null;

// won't log anything, depending on timeout duration
setTimeout(() => {
  for (const value of w) {
    console.log(value)
  }
}, 1000)