mild-map 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 declare class MildMap<K, V> {
     #private;
     constructor(entries?: readonly (readonly [K, V])[] | null);
+    get size(): number;
     delete(key: K): boolean;
     get(key: K): V | undefined;
     has(key: K): boolean;

package/dist/index.js

@@ -5,20 +5,39 @@ class MildMap {
     /* VARIABLES */
     #strong;
     #weak;
+    #size;
+    #finalizationRegistry;
+    #finalizationTokens;
     /* CONSTRUCTOR */
     constructor(entries) {
         /* VARIABLES */
         this.#strong = new Map();
         this.#weak = new WeakMap();
+        this.#size = 0;
+        this.#finalizationRegistry = new FinalizationRegistry(() => this.#size -= 1);
+        this.#finalizationTokens = new WeakMap();
         if (entries) {
             for (const [key, value] of entries) {
                 this.set(key, value);
             }
         }
     }
+    /* GETTER API */
+    get size() {
+        return this.#size;
+    }
     /* API */
     delete(key) {
+        const hasKey = this.has(key);
+        if (!hasKey)
+            return false;
+        this.#size -= 1;
         if (isWeakReferrable(key)) {
+            const token = this.#finalizationTokens.get(key);
+            if (token) {
+                this.#finalizationRegistry.unregister(token);
+                this.#finalizationTokens.delete(key);
+            }
             return this.#weak.delete(key);
         }
         else {
@@ -42,8 +61,17 @@ class MildMap {
         }
     }
     set(key, value) {
+        const hasKey = this.has(key);
+        if (!hasKey) {
+            this.#size += 1;
+        }
         if (isWeakReferrable(key)) {
             this.#weak.set(key, value);
+            if (!hasKey) {
+                const token = {};
+                this.#finalizationRegistry.register(key, token, token);
+                this.#finalizationTokens.set(key, token);
+            }
         }
         else {
             this.#strong.set(key, value);

package/dist/utils.d.ts

@@ -1,2 +1,2 @@
-declare const isWeakReferrable: (value: unknown) => value is symbol | object;
+declare const isWeakReferrable: (value: unknown) => value is object;
 export { isWeakReferrable };

package/package.json

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

package/readme.md

@@ -12,6 +12,8 @@ npm install --save mild-map
 
 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.
+
 ## License
 
 MIT © Fabio Spampinato

package/src/index.ts

@@ -11,6 +11,10 @@ class MildMap<K, V> {
 
   #strong = new Map<K, V> ();
   #weak = new WeakMap<any, V> ();
+  #size = 0;
+
+  #finalizationRegistry = new FinalizationRegistry ( () => this.#size -= 1 );
+  #finalizationTokens = new WeakMap<object, object> ();
 
   /* CONSTRUCTOR */
 
@@ -28,12 +32,35 @@ class MildMap<K, V> {
 
   }
 
+  /* GETTER API */
+
+  get size () {
+
+    return this.#size;
+
+  }
+
   /* API */
 
   delete ( key: K ): boolean {
 
+    const hasKey = this.has ( key );
+
+    if ( !hasKey ) return false;
+
+    this.#size -= 1;
+
     if ( isWeakReferrable ( key ) ) {
 
+      const token = this.#finalizationTokens.get ( key );
+
+      if ( token ) {
+
+        this.#finalizationRegistry.unregister ( token );
+        this.#finalizationTokens.delete ( key );
+
+      }
+
       return this.#weak.delete ( key );
 
     } else {
@@ -74,10 +101,27 @@ class MildMap<K, V> {
 
   set ( key: K, value: V ): this {
 
+    const hasKey = this.has ( key );
+
+    if ( !hasKey ) {
+
+      this.#size += 1;
+
+    }
+
     if ( isWeakReferrable ( key ) ) {
 
       this.#weak.set ( key, value );
 
+      if ( !hasKey ) {
+
+        const token = {};
+
+        this.#finalizationRegistry.register ( key, token, token );
+        this.#finalizationTokens.set ( key, token );
+
+      }
+
     } else {
 
       this.#strong.set ( key, value );

package/src/utils.ts

@@ -5,7 +5,7 @@ import {SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS} from './constants';
 
 /* IMPORT */
 
-const isWeakReferrable = ( value: unknown ): value is object | symbol => {
+const isWeakReferrable = ( value: unknown ): value is object => {
 
   if ( value === null ) return false;
 

package/test/index.js

@@ -16,6 +16,8 @@ describe ( 'MildMap', it => {
     let primitive = 0;
     let object = {};
 
+    t.is ( map.size, 0 );
+
     t.is ( map.get ( primitive ), undefined );
     t.is ( map.get ( object ), undefined );
 
@@ -28,6 +30,8 @@ describe ( 'MildMap', it => {
     map.set ( primitive, 'primitive' );
     map.set ( object, 'object' );
 
+    t.is ( map.size, 2 );
+
     t.is ( map.get ( primitive ), 'primitive' );
     t.is ( map.get ( object ), 'object' );
 
@@ -37,9 +41,13 @@ describe ( 'MildMap', it => {
     t.true ( map.delete ( primitive ) );
     t.true ( map.delete ( object ) );
 
+    t.is ( map.size, 0 );
+
     map.set ( primitive, 'primitive' );
     map.set ( object, 'object' );
 
+    t.is ( map.size, 2 );
+
     /* CLEANUP */
 
     let deleted = 0;
@@ -55,6 +63,7 @@ describe ( 'MildMap', it => {
     await delay ( 500 );
 
     t.is ( deleted, 1 );
+    t.is ( map.size, 1 );
 
   });