mild-set 1.0.0

package/.editorconfig

@@ -0,0 +1,10 @@
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true

package/dist/constants.d.ts

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

package/dist/constants.js

@@ -0,0 +1,12 @@
+/* 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/index.d.ts

@@ -0,0 +1,8 @@
+declare class MildSet<V> {
+    #private;
+    constructor(entries?: readonly V[] | null);
+    add(value: V): this;
+    delete(value: V): boolean;
+    has(value: V): boolean;
+}
+export default MildSet;

package/dist/index.js

@@ -0,0 +1,47 @@
+/* IMPORT */
+import { isWeakReferrable } from './utils.js';
+/* MAIN */
+class MildSet {
+    /* VARIABLES */
+    #strong;
+    #weak;
+    /* CONSTRUCTOR */
+    constructor(entries) {
+        /* VARIABLES */
+        this.#strong = new Set();
+        this.#weak = new WeakSet();
+        if (entries) {
+            for (const value of entries) {
+                this.add(value);
+            }
+        }
+    }
+    /* API */
+    add(value) {
+        if (isWeakReferrable(value)) {
+            this.#weak.add(value);
+        }
+        else {
+            this.#strong.add(value);
+        }
+        return this;
+    }
+    delete(value) {
+        if (isWeakReferrable(value)) {
+            return this.#weak.delete(value);
+        }
+        else {
+            return this.#strong.delete(value);
+        }
+    }
+    has(value) {
+        if (isWeakReferrable(value)) {
+            return this.#weak.has(value);
+        }
+        else {
+            return this.#strong.has(value);
+        }
+    }
+}
+/* EXPORT */
+export default MildSet;

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -0,0 +1,11 @@
+/* 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/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023-present Fabio Spampinato
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,27 @@
+{
+  "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",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "clean": "tsex clean",
+    "compile": "tsex compile",
+    "compile:watch": "tsex compile --watch",
+    "test": "node --expose-gc test/index.js",
+    "prepublishOnly": "npm run clean && npm run compile && npm run test"
+  },
+  "keywords": [
+    "weak",
+    "strong",
+    "map"
+  ],
+  "devDependencies": {
+    "fava": "^0.1.2",
+    "tsex": "^2.1.0",
+    "typescript": "^4.9.5"
+  }
+}

package/readme.md

@@ -0,0 +1,17 @@
+# MildSet
+
+A WeakSet that supports any value, it holds strong references to primitives, and weak references to objects.
+
+## Install
+
+```sh
+npm install --save mild-set
+```
+
+## Usage
+
+It has the same API of a WeakSet, except that it just works with primitives too.
+
+## License
+
+MIT © Fabio Spampinato

package/src/constants.ts

@@ -0,0 +1,22 @@
+
+/* 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/index.ts

@@ -0,0 +1,81 @@
+
+/* IMPORT */
+
+import {isWeakReferrable} from './utils';
+
+/* MAIN */
+
+class MildSet<V> {
+
+  /* VARIABLES */
+
+  #strong = new Set<V> ();
+  #weak = new WeakSet<any> ();
+
+  /* CONSTRUCTOR */
+
+  constructor ( entries?: readonly V[] | null ) {
+
+    if ( entries ) {
+
+      for ( const value of entries ) {
+
+        this.add ( value );
+
+      }
+
+    }
+
+  }
+
+  /* API */
+
+  add ( value: V ): this {
+
+    if ( isWeakReferrable ( value ) ) {
+
+      this.#weak.add ( value );
+
+    } else {
+
+      this.#strong.add ( value );
+
+    }
+
+    return this;
+
+  }
+
+  delete ( value: V ): boolean {
+
+    if ( isWeakReferrable ( value ) ) {
+
+      return this.#weak.delete ( value );
+
+    } else {
+
+      return this.#strong.delete ( value );
+
+    }
+
+  }
+
+  has ( value: V ): boolean {
+
+    if ( isWeakReferrable ( value ) ) {
+
+      return this.#weak.has ( value );
+
+    } else {
+
+      return this.#strong.has ( value );
+
+    }
+
+  }
+
+}
+
+/* EXPORT */
+
+export default MildSet;

package/src/utils.ts

@@ -0,0 +1,20 @@
+
+/* 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};

package/test/index.js

@@ -0,0 +1,55 @@
+
+/* IMPORT */
+
+import {describe} from 'fava';
+import {setTimeout as delay} from 'node:timers/promises';
+import MildSet from '../dist/index.js';
+
+/* MAIN */
+
+describe ( 'MildSet', it => {
+
+  it ( 'works', async t => {
+
+    const set = new MildSet ();
+
+    let primitive = 0;
+    let object = {};
+
+    t.false ( set.has ( primitive ) );
+    t.false ( set.has ( object ) );
+
+    t.false ( set.delete ( primitive ) );
+    t.false ( set.delete ( object ) );
+
+    set.add ( primitive );
+    set.add ( object );
+
+    t.true ( set.has ( primitive ) );
+    t.true ( set.has ( object ) );
+
+    t.true ( set.delete ( primitive ) );
+    t.true ( set.delete ( object ) );
+
+    set.add ( primitive );
+    set.add ( object );
+
+    /* CLEANUP */
+
+    let deleted = 0;
+
+    const registry = new FinalizationRegistry ( () => deleted++ );
+
+    registry.register ( object );
+
+    object = null;
+
+    await delay ( 500 );
+    global.gc ();
+    await delay ( 500 );
+
+    t.is ( deleted, 1 );
+
+  });
+
+});

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "tsex/tsconfig.json",
+  "compilerOptions": {
+    "target": "es2022"
+  }
+}