mild-map 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_WEAKMAP_KEYS: boolean;
+export { SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS };

package/dist/constants.js

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

@@ -0,0 +1,9 @@
+declare class MildMap<K, V> {
+    #private;
+    constructor(entries?: readonly (readonly [K, V])[] | null);
+    delete(key: K): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+}
+export default MildMap;

package/dist/index.js

@@ -0,0 +1,55 @@
+/* IMPORT */
+import { isWeakReferrable } from './utils.js';
+/* MAIN */
+class MildMap {
+    /* VARIABLES */
+    #strong;
+    #weak;
+    /* CONSTRUCTOR */
+    constructor(entries) {
+        /* VARIABLES */
+        this.#strong = new Map();
+        this.#weak = new WeakMap();
+        if (entries) {
+            for (const [key, value] of entries) {
+                this.set(key, value);
+            }
+        }
+    }
+    /* API */
+    delete(key) {
+        if (isWeakReferrable(key)) {
+            return this.#weak.delete(key);
+        }
+        else {
+            return this.#strong.delete(key);
+        }
+    }
+    get(key) {
+        if (isWeakReferrable(key)) {
+            return this.#weak.get(key);
+        }
+        else {
+            return this.#strong.get(key);
+        }
+    }
+    has(key) {
+        if (isWeakReferrable(key)) {
+            return this.#weak.has(key);
+        }
+        else {
+            return this.#strong.has(key);
+        }
+    }
+    set(key, value) {
+        if (isWeakReferrable(key)) {
+            this.#weak.set(key, value);
+        }
+        else {
+            this.#strong.set(key, value);
+        }
+        return this;
+    }
+}
+/* EXPORT */
+export default MildMap;

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_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/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-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",
+  "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 @@
+# MildMap
+
+A WeakMap that supports any value, it holds strong references to primitives, and weak references to objects.
+
+## Install
+
+```sh
+npm install --save mild-map
+```
+
+## Usage
+
+It has the same API of a WeakMap, 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_WEAKMAP_KEYS = ((): boolean => {
+
+  try {
+
+    new WeakMap ().set ( Symbol (), 0 );
+
+    return true;
+
+  } catch {
+
+    return false;
+
+  }
+
+})();
+
+/* EXPORT */
+
+export {SUPPORTS_SYMBOLS_AS_WEAKMAP_KEYS};

package/src/index.ts

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

package/src/utils.ts

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

package/test/index.js

@@ -0,0 +1,61 @@
+
+/* IMPORT */
+
+import {describe} from 'fava';
+import {setTimeout as delay} from 'node:timers/promises';
+import MildMap from '../dist/index.js';
+
+/* MAIN */
+
+describe ( 'MildMap', it => {
+
+  it ( 'works', async t => {
+
+    const map = new MildMap ();
+
+    let primitive = 0;
+    let object = {};
+
+    t.is ( map.get ( primitive ), undefined );
+    t.is ( map.get ( object ), undefined );
+
+    t.false ( map.has ( primitive ) );
+    t.false ( map.has ( object ) );
+
+    t.false ( map.delete ( primitive ) );
+    t.false ( map.delete ( object ) );
+
+    map.set ( primitive, 'primitive' );
+    map.set ( object, 'object' );
+
+    t.is ( map.get ( primitive ), 'primitive' );
+    t.is ( map.get ( object ), 'object' );
+
+    t.true ( map.has ( primitive ) );
+    t.true ( map.has ( object ) );
+
+    t.true ( map.delete ( primitive ) );
+    t.true ( map.delete ( object ) );
+
+    map.set ( primitive, 'primitive' );
+    map.set ( object, '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"
+  }
+}