mild-set 1.0.0 → 1.1.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -5,21 +5,40 @@ class MildSet {
     /* VARIABLES */
     #strong;
     #weak;
+    #size;
+    #finalizationRegistry;
+    #finalizationTokens;
     /* CONSTRUCTOR */
     constructor(entries) {
         /* VARIABLES */
         this.#strong = new Set();
         this.#weak = new WeakSet();
+        this.#size = 0;
+        this.#finalizationRegistry = new FinalizationRegistry(() => this.#size -= 1);
+        this.#finalizationTokens = new WeakMap();
         if (entries) {
             for (const value of entries) {
                 this.add(value);
             }
         }
     }
+    /* GETTER API */
+    get size() {
+        return this.#size;
+    }
     /* API */
     add(value) {
+        const hasValue = this.has(value);
+        if (!hasValue) {
+            this.#size += 1;
+        }
         if (isWeakReferrable(value)) {
             this.#weak.add(value);
+            if (!hasValue) {
+                const token = {};
+                this.#finalizationRegistry.register(value, token, token);
+                this.#finalizationTokens.set(value, token);
+            }
         }
         else {
             this.#strong.add(value);
@@ -27,7 +46,16 @@ class MildSet {
         return this;
     }
     delete(value) {
+        const hasValue = this.has(value);
+        if (!hasValue)
+            return false;
+        this.#size -= 1;
         if (isWeakReferrable(value)) {
+            const token = this.#finalizationTokens.get(value);
+            if (token) {
+                this.#finalizationRegistry.unregister(token);
+                this.#finalizationTokens.delete(value);
+            }
             return this.#weak.delete(value);
         }
         else {

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-set",
   "repository": "github:fabiospampinato/mild-set",
   "description": "A WeakSet 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",
@@ -17,7 +17,7 @@
   "keywords": [
     "weak",
     "strong",
-    "map"
+    "set"
   ],
   "devDependencies": {
     "fava": "^0.1.2",

package/readme.md

@@ -12,6 +12,8 @@ npm install --save mild-set
 
 It has the same API of a WeakSet, except that it just works with primitives too.
 
+It also implements the `size` property, like a Set.
+
 ## License
 
 MIT © Fabio Spampinato

package/src/index.ts

@@ -11,6 +11,10 @@ class MildSet<V> {
 
   #strong = new Set<V> ();
   #weak = new WeakSet<any> ();
+  #size = 0;
+
+  #finalizationRegistry = new FinalizationRegistry ( () => this.#size -= 1 );
+  #finalizationTokens = new WeakMap<object, object> ();
 
   /* CONSTRUCTOR */
 
@@ -28,14 +32,39 @@ class MildSet<V> {
 
   }
 
+  /* GETTER API */
+
+  get size () {
+
+    return this.#size;
+
+  }
+
   /* API */
 
   add ( value: V ): this {
 
+    const hasValue = this.has ( value );
+
+    if ( !hasValue ) {
+
+      this.#size += 1;
+
+    }
+
     if ( isWeakReferrable ( value ) ) {
 
       this.#weak.add ( value );
 
+      if ( !hasValue ) {
+
+        const token = {};
+
+        this.#finalizationRegistry.register ( value, token, token );
+        this.#finalizationTokens.set ( value, token );
+
+      }
+
     } else {
 
       this.#strong.add ( value );
@@ -48,8 +77,23 @@ class MildSet<V> {
 
   delete ( value: V ): boolean {
 
+    const hasValue = this.has ( value );
+
+    if ( !hasValue ) return false;
+
+    this.#size -= 1;
+
     if ( isWeakReferrable ( value ) ) {
 
+      const token = this.#finalizationTokens.get ( value );
+
+      if ( token ) {
+
+        this.#finalizationRegistry.unregister ( token );
+        this.#finalizationTokens.delete ( value );
+
+      }
+
       return this.#weak.delete ( value );
 
     } else {

package/src/utils.ts

@@ -5,7 +5,7 @@ import {SUPPORTS_SYMBOLS_AS_WEAKSET_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 ( 'MildSet', it => {
     let primitive = 0;
     let object = {};
 
+    t.is ( set.size, 0 );
+
     t.false ( set.has ( primitive ) );
     t.false ( set.has ( object ) );
 
@@ -25,15 +27,21 @@ describe ( 'MildSet', it => {
     set.add ( primitive );
     set.add ( object );
 
+    t.is ( set.size, 2 );
+
     t.true ( set.has ( primitive ) );
     t.true ( set.has ( object ) );
 
     t.true ( set.delete ( primitive ) );
     t.true ( set.delete ( object ) );
 
+    t.is ( set.size, 0 );
+
     set.add ( primitive );
     set.add ( object );
 
+    t.is ( set.size, 2 );
+
     /* CLEANUP */
 
     let deleted = 0;
@@ -49,6 +57,7 @@ describe ( 'MildSet', it => {
     await delay ( 500 );
 
     t.is ( deleted, 1 );
+    t.is ( set.size, 1 );
 
   });