mild-map 1.0.0 → 1.1.1

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

@@ -1,24 +1,47 @@
 /* IMPORT */
-import { isWeakReferrable } from './utils.js';
+import { isWeakReferable } from 'is';
+/* HELPERS */
+const isWeakabe = (value) => {
+    return isWeakReferable(value);
+};
 /* MAIN */
 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) {
-        if (isWeakReferrable(key)) {
+        const hasKey = this.has(key);
+        if (!hasKey)
+            return false;
+        this.#size -= 1;
+        if (isWeakabe(key)) {
+            const token = this.#finalizationTokens.get(key);
+            if (token) {
+                this.#finalizationRegistry.unregister(token);
+                this.#finalizationTokens.delete(key);
+            }
             return this.#weak.delete(key);
         }
         else {
@@ -26,7 +49,7 @@ class MildMap {
         }
     }
     get(key) {
-        if (isWeakReferrable(key)) {
+        if (isWeakabe(key)) {
             return this.#weak.get(key);
         }
         else {
@@ -34,7 +57,7 @@ class MildMap {
         }
     }
     has(key) {
-        if (isWeakReferrable(key)) {
+        if (isWeakabe(key)) {
             return this.#weak.has(key);
         }
         else {
@@ -42,8 +65,17 @@ class MildMap {
         }
     }
     set(key, value) {
-        if (isWeakReferrable(key)) {
+        const hasKey = this.has(key);
+        if (!hasKey) {
+            this.#size += 1;
+        }
+        if (isWeakabe(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/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.1",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",
@@ -19,9 +19,12 @@
     "strong",
     "map"
   ],
+  "dependencies": {
+    "is": "npm:@fabiospampinato/is@^2.5.0"
+  },
   "devDependencies": {
-    "fava": "^0.1.2",
-    "tsex": "^2.1.0",
+    "fava": "^0.2.0",
+    "tsex": "^2.2.0",
     "typescript": "^4.9.5"
   }
 }

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

@@ -1,7 +1,13 @@
 
 /* IMPORT */
 
-import {isWeakReferrable} from './utils';
+import {isWeakReferable} from 'is';
+
+/* HELPERS */
+
+const isWeakabe = ( value: unknown ): value is object => { //FIXME: Overridden type guard for convenience, delete this once TS updates its types
+  return isWeakReferable ( value );
+};
 
 /* MAIN */
 
@@ -11,6 +17,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,11 +38,34 @@ class MildMap<K, V> {
 
   }
 
+  /* GETTER API */
+
+  get size () {
+
+    return this.#size;
+
+  }
+
   /* API */
 
   delete ( key: K ): boolean {
 
-    if ( isWeakReferrable ( key ) ) {
+    const hasKey = this.has ( key );
+
+    if ( !hasKey ) return false;
+
+    this.#size -= 1;
+
+    if ( isWeakabe ( key ) ) {
+
+      const token = this.#finalizationTokens.get ( key );
+
+      if ( token ) {
+
+        this.#finalizationRegistry.unregister ( token );
+        this.#finalizationTokens.delete ( key );
+
+      }
 
       return this.#weak.delete ( key );
 
@@ -46,7 +79,7 @@ class MildMap<K, V> {
 
   get ( key: K ): V | undefined {
 
-    if ( isWeakReferrable ( key ) ) {
+    if ( isWeakabe ( key ) ) {
 
       return this.#weak.get ( key );
 
@@ -60,7 +93,7 @@ class MildMap<K, V> {
 
   has ( key: K ): boolean {
 
-    if ( isWeakReferrable ( key ) ) {
+    if ( isWeakabe ( key ) ) {
 
       return this.#weak.has ( key );
 
@@ -74,10 +107,27 @@ class MildMap<K, V> {
 
   set ( key: K, value: V ): this {
 
-    if ( isWeakReferrable ( key ) ) {
+    const hasKey = this.has ( key );
+
+    if ( !hasKey ) {
+
+      this.#size += 1;
+
+    }
+
+    if ( isWeakabe ( 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/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 );
 
   });
 

package/dist/constants.d.ts

@@ -1,2 +0,0 @@
-declare const SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS: boolean;
-export { SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS };

package/dist/constants.js

@@ -1,12 +0,0 @@
-/* MAIN */
-const SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS = (() => {
-    try {
-        new WeakMap().set(Symbol(), 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-})();
-/* EXPORT */
-export { SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS };

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -1,11 +0,0 @@
-/* IMPORT */
-import { SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS } from './constants.js';
-/* IMPORT */
-const isWeakReferrable = (value) => {
-    if (value === null)
-        return false;
-    const type = typeof value;
-    return type === 'object' || type === 'function' || (SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS && type === 'symbol');
-};
-/* EXPORT */
-export { isWeakReferrable };

package/src/constants.ts

@@ -1,22 +0,0 @@
-
-/* MAIN */
-
-const SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS = ((): boolean => {
-
-  try {
-
-    new WeakMap ().set ( Symbol (), 0 );
-
-    return true;
-
-  } catch {
-
-    return false;
-
-  }
-
-})();
-
-/* EXPORT */
-
-export {SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS};

package/src/utils.ts

@@ -1,20 +0,0 @@
-
-/* IMPORT */
-
-import {SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS} from './constants';
-
-/* IMPORT */
-
-const isWeakReferrable = ( value: unknown ): value is object | symbol => {
-
-  if ( value === null ) return false;
-
-  const type = typeof value;
-
-  return type === 'object' || type === 'function' || ( SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS && type === 'symbol' );
-
-};
-
-/* EXPORT */
-
-export {isWeakReferrable};