mild-map 1.1.2 → 1.2.0

package/dist/index.d.ts

@@ -6,5 +6,10 @@ declare class MildMap<K, V> {
     get(key: K): V | undefined;
     has(key: K): boolean;
     set(key: K, value: V): this;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    forEach(callback: (value: V, key: K, map: MildMap<K, V>) => void, thisArg?: any): undefined;
 }
 export default MildMap;

package/dist/index.js

@@ -5,9 +5,14 @@ class MildMap {
     /* VARIABLES */
     #strong = new Map();
     #weak = new WeakMap();
+    #weakRefs = new Set();
+    #weakRefsMap = new WeakMap();
     #size = 0;
-    #finalizationRegistry = new FinalizationRegistry(() => this.#size -= 1);
     #finalizationTokens = new WeakMap();
+    #finalizationRegistry = new FinalizationRegistry(weakRef => {
+        this.#size -= 1;
+        this.#weakRefs.delete(weakRef);
+    });
     /* CONSTRUCTOR */
     constructor(entries) {
         if (entries) {
@@ -31,6 +36,11 @@ class MildMap {
             if (token) {
                 this.#finalizationRegistry.unregister(token);
                 this.#finalizationTokens.delete(key);
+                const weakRef = this.#weakRefsMap.get(key);
+                if (weakRef) {
+                    this.#weakRefs.delete(weakRef);
+                    this.#weakRefsMap.delete(key);
+                }
             }
             return this.#weak.delete(key);
         }
@@ -62,8 +72,11 @@ class MildMap {
         if (isWeakReferable(key)) {
             this.#weak.set(key, value);
             if (!hasKey) {
+                const weakRef = new WeakRef(key);
                 const token = {};
-                this.#finalizationRegistry.register(key, token, token);
+                this.#weakRefs.add(weakRef);
+                this.#weakRefsMap.set(key, weakRef);
+                this.#finalizationRegistry.register(key, weakRef, token);
                 this.#finalizationTokens.set(key, token);
             }
         }
@@ -72,6 +85,44 @@ class MildMap {
         }
         return this;
     }
+    /* ITERATION API */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    *keys() {
+        yield* this.#strong.keys();
+        for (const weakRef of this.#weakRefs) {
+            const key = weakRef.deref();
+            if (key === undefined)
+                continue;
+            yield key;
+        }
+    }
+    *values() {
+        yield* this.#strong.values();
+        for (const weakRef of this.#weakRefs) {
+            const key = weakRef.deref();
+            if (key === undefined || !this.#weak.has(key))
+                continue;
+            const value = this.#weak.get(key);
+            yield value;
+        }
+    }
+    *entries() {
+        yield* this.#strong.entries();
+        for (const weakRef of this.#weakRefs) {
+            const key = weakRef.deref();
+            if (key === undefined || !this.#weak.has(key))
+                continue;
+            const value = this.#weak.get(key);
+            yield [key, value];
+        }
+    }
+    forEach(callback, thisArg) {
+        for (const [key, value] of this.entries()) {
+            callback.call(thisArg, value, key, this);
+        }
+    }
 }
 /* EXPORT */
 export default MildMap;

package/package.json

@@ -3,7 +3,7 @@
   "repository": "github:fabiospampinato/mild-map",
   "description": "A WeakMap that supports any value, it holds strong references to primitives, and weak references to objects.",
   "license": "MIT",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",

package/readme.md

@@ -14,6 +14,8 @@ It has the same API of a WeakMap, except that it just works with primitives too.
 
 It also implements the `size` property, like a Map.
 
+It also implements all the iteration methods, like a Map.
+
 ## License
 
 MIT © Fabio Spampinato