Iterable WeakMap implemented using Weak References

iterable-weak-key-map.js

function IterableWeakKeyMap() {
  const keyMap = new WeakMap();
  const refValueMap = new Map();
  return Object.freeze({
    get: function(key) {
      const entry = keyMap.get(key);
      return entry && entry.value;
    },
    set: function(key, value) {
      const ref = makeWeakRef(key);
      keyMap.set(key, {value: value, ref: ref});
      refValueMap.set(ref, value);
      ref.register(function() {
        refValueMap.delete(ref);
      });
    },
    delete: function(key) {
      const entry = keyMap.get(key);
      if (!entry) {
        return;
      }
      keyMap.delete(key);
      refValueMap.delete(entry.ref);
    },
    iterator: function() {
      for (const item of refValueMap) {
        const key = item[0].get();
        if (key) {
          yield [key, item[1]];
        }
      }
    },
    items: function() {
      return this.iterator();
    },
    keys: function() {
      for (const ref of refValueMap.keys()) {
        const key = ref.get();
        if (key) {
          yield key;
        }
      }
    },
    values: function() {
      // Not sure if we also need to filter these
      return refValueMap.values();
    }
  }); 
}

Updated using the new WeakRef API (+ESNext sauce):

class IterableWeakMap {
  #weakMap = new WeakMap();
  #refMap = new Map();
  #finalizationGroup = new FinalizationGroup(IterableWeakMap.#cleanup);

  static #cleanup(iterator) {
    for (const { map, ref } of iterator) {
      map.delete(ref);
    }
  }

  set(key, value) {
    const ref = new WeakRef(key);

    this.#weakMap.set(key, { value, ref });
    this.#refMap.set(ref, value);
    finalizationGroup.register(key, { map: this.#weakRefMap, ref }, ref);
  }

  get(key) {
    const entry = this.#weakMap.get(key);
    return entry && entry.value;
  }

  delete(key) {
    const entry = this.#weakMap.get(key);
    if (!entry) {
      return;
    }

    this.#weakMap.delete(key);
    this.#refMap.delete(entry.ref);
    this.#finalizationGroup.unregister(entry.ref);
  }

  *iterator() {
    for (const [ref, value] of this.#refMap) {
      const key = ref.get();
      if (key) yield [key, value];
    }
  }

  items() {
    return this.iterator();
  }

  *keys() {
    for (const [ref] of this.#refMap) {
      const key = ref.get();
      if (key) yield key;
    }
  }

  values() {
    return this.#refMap.values();
  }
}

A warning if using the code above. There is a bug in the set method if the same key is used multiple times. This will cause multiple weak references for the same key in the #refMap. A simple solution is to call this.delete(ref) after creating the WeakRef .

map = new IterableWeakMap():
const key1 = Symbol('1');

map.set(key1, 'TEST_1');
map.set(key1, 'TEST_1_1');

map.values() // Returns ['TEST_1', 'TEST_1_1']

Seems pretty complex for something that should be as simple as possible. Here is my version in Typescript, please tag me if you find any issues (known issue would be desynchronization of array maps, but this should be clearly visible in this small flow):

export interface IIterableWeakMap<T extends object, P> {
  get: (key: T) => P|undefined;
  set: (key: T, value: P) => IIterableWeakMap<T, P>;
  delete: (key: T) => boolean;
  has: (key: T) => boolean;
  keys: () => T[];
  values: () => P[];
  [Symbol.toStringTag]: string;
}
export default function IterableWeakMap<T extends object, P>(): IIterableWeakMap<T, P> {
  const weakMap = new WeakMap(),
    arrKeys: T[] = [],
    arrValues: P[] = [],
    objectToIndex = new WeakMap<T, number>(),
    _ = {
      get [Symbol.toStringTag]() {
        return 'IterableWeakMap';
      },
      get: (key: T): P|undefined => weakMap.get(key) as P|undefined,
      set: (key: T, value: P): IIterableWeakMap<T, P> => {
        weakMap.set(key, value);
        objectToIndex.set(key, arrKeys.length);
        arrKeys.push(key);
        arrValues.push(value);

        return _;
      },
      delete: (key: T): boolean => {
        if (!weakMap.get(key) || !objectToIndex.has(key)) {
          return false;
        }
        weakMap.delete(key);
        arrKeys.splice(objectToIndex.get(key)!, 1);
        arrValues.splice(objectToIndex.get(key)!, 1);
        objectToIndex.delete(key);

        return true;
      },
      has: (key: T): boolean => weakMap.has(key),
      keys: (): T[] => arrKeys,
      values: (): P[] => arrValues,
    }
  ;
  return Object.freeze(_);
}