mild-set 1.0.0 → 1.1.1

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

@@ -1,25 +1,48 @@
 /* IMPORT */
-import { isWeakReferrable } from './utils.js';
+import { isWeakReferable } from 'is';
+/* HELPERS */
+const isWeakable = (value) => {
+    return isWeakReferable(value);
+};
 /* MAIN */
 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) {
-        if (isWeakReferrable(value)) {
+        const hasValue = this.has(value);
+        if (!hasValue) {
+            this.#size += 1;
+        }
+        if (isWeakable(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 +50,16 @@ class MildSet {
         return this;
     }
     delete(value) {
-        if (isWeakReferrable(value)) {
+        const hasValue = this.has(value);
+        if (!hasValue)
+            return false;
+        this.#size -= 1;
+        if (isWeakable(value)) {
+            const token = this.#finalizationTokens.get(value);
+            if (token) {
+                this.#finalizationRegistry.unregister(token);
+                this.#finalizationTokens.delete(value);
+            }
             return this.#weak.delete(value);
         }
         else {
@@ -35,7 +67,7 @@ class MildSet {
         }
     }
     has(value) {
-        if (isWeakReferrable(value)) {
+        if (isWeakable(value)) {
             return this.#weak.has(value);
         }
         else {

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.1",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",
@@ -17,11 +17,14 @@
   "keywords": [
     "weak",
     "strong",
-    "map"
+    "set"
   ],
+  "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-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

@@ -1,7 +1,13 @@
 
 /* IMPORT */
 
-import {isWeakReferrable} from './utils';
+import {isWeakReferable} from 'is';
+
+/* HELPERS */
+
+const isWeakable = ( 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 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 +38,39 @@ class MildSet<V> {
 
   }
 
+  /* GETTER API */
+
+  get size () {
+
+    return this.#size;
+
+  }
+
   /* API */
 
   add ( value: V ): this {
 
-    if ( isWeakReferrable ( value ) ) {
+    const hasValue = this.has ( value );
+
+    if ( !hasValue ) {
+
+      this.#size += 1;
+
+    }
+
+    if ( isWeakable ( 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,7 +83,22 @@ class MildSet<V> {
 
   delete ( value: V ): boolean {
 
-    if ( isWeakReferrable ( value ) ) {
+    const hasValue = this.has ( value );
+
+    if ( !hasValue ) return false;
+
+    this.#size -= 1;
+
+    if ( isWeakable ( value ) ) {
+
+      const token = this.#finalizationTokens.get ( value );
+
+      if ( token ) {
+
+        this.#finalizationRegistry.unregister ( token );
+        this.#finalizationTokens.delete ( value );
+
+      }
 
       return this.#weak.delete ( value );
 
@@ -62,7 +112,7 @@ class MildSet<V> {
 
   has ( value: V ): boolean {
 
-    if ( isWeakReferrable ( value ) ) {
+    if ( isWeakable ( value ) ) {
 
       return this.#weak.has ( value );
 

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 );
 
   });
 

package/dist/constants.d.ts

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

package/dist/constants.js

@@ -1,12 +0,0 @@
-/* MAIN */
-const SUPPORTS_SYMBOLS_AS_WEAKSET_KEYS = (() => {
-    try {
-        new WeakSet().add(Symbol());
-        return true;
-    }
-    catch {
-        return false;
-    }
-})();
-/* EXPORT */
-export { SUPPORTS_SYMBOLS_AS_WEAKSET_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_WEAKSET_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_WEAKSET_KEYS && type === 'symbol');
-};
-/* EXPORT */
-export { isWeakReferrable };

package/src/constants.ts

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

package/src/utils.ts

@@ -1,20 +0,0 @@
-
-/* IMPORT */
-
-import {SUPPORTS_SYMBOLS_AS_WEAKSET_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_WEAKSET_KEYS && type === 'symbol' );
-
-};
-
-/* EXPORT */
-
-export {isWeakReferrable};