@rhombus-toolkit/collections 2.0.0 → 2.0.2

package/dist/bundle/index.d.ts

@@ -1,12 +1,8 @@
 /**
- * Extending answers a new list sharing everything already there, so whoever holds one reads
- * exactly what it held however much is added or removed afterwards.
+ * A persistent singly-linked list — extending shares everything already there.
  *
  * @remarks
- * Both ends are known. {@link push} adds at the head and shares the whole list after it, which
- * leaves the tail the same link it already was — so a list knows what it ends with without ever
- * walking to find out. {@link tailToHead} is settled once per list and answered from then on, which
- * is what lets a list be read from its tail as often as wanted without paying to reverse it.
+ * {@link tail} is O(1); {@link tailToHead} reverses once and caches the result.
  */
 declare class ImmutableLinkedList<T> implements Iterable<T> {
     #private;
@@ -32,18 +28,20 @@ declare class ImmutableLinkedList<T> implements Iterable<T> {
     tailToHead(): readonly T[];
 }
 
-declare class KindaWeakMap<K, V extends object> {
+declare class KindaWeakMap<K, V extends WeakKey> {
     #private;
+    /** An existing key keeps its place in iteration order, as with `Map`. */
     set(key: K, value: V): this;
     delete(key: K): boolean;
     get(key: K): V | undefined;
     has(key: K): boolean;
     clear(): void;
     forEach(callbackfn: (value: V, key: K, map: this) => void, thisArg?: any): void;
+    /** Counts only entries whose value is still alive, so it walks every ref. */
     get size(): number;
     entries(): MapIterator<[K, V]>;
     keys(): MapIterator<K>;
-    values(): MapIterator<V | undefined>;
+    values(): MapIterator<V>;
     [Symbol.iterator](): MapIterator<[K, V]>;
     readonly [Symbol.toStringTag]: "KindaWeakMap";
 }

package/dist/bundle/index.js

@@ -60,34 +60,38 @@ function tailOf(link) {
 // src/KindaWeakMap.ts
 class KindaWeakMap {
   #map = new Map;
-  #registry = new FinalizationRegistry((key) => {
-    if (this.#map.get(key)?.deref() === undefined) {
+  #registry = new FinalizationRegistry(({ key, ref }) => {
+    if (this.#map.get(key) === ref) {
       this.#map.delete(key);
     }
   });
   set(key, value) {
-    if (this.has(key)) {
-      this.delete(key);
+    const held = this.#map.get(key);
+    if (held) {
+      this.#registry.unregister(held);
     }
-    this.#registry.register(value, key, value);
-    this.#map.set(key, new WeakRef(value));
+    const ref = new WeakRef(value);
+    this.#registry.register(value, { key, ref }, ref);
+    this.#map.set(key, ref);
     return this;
   }
   delete(key) {
-    const val = this.get(key);
-    if (val !== undefined) {
-      this.#registry.unregister(val);
+    const held = this.#map.get(key);
+    if (!held) {
+      return false;
     }
-    return this.#map.delete(key);
+    this.#map.delete(key);
+    this.#registry.unregister(held);
+    return held.deref() !== undefined;
   }
   get(key) {
     return this.#map.get(key)?.deref();
   }
   has(key) {
-    return this.#map.has(key);
+    return this.get(key) !== undefined;
   }
   clear() {
-    this.values().filter(Boolean).forEach((p) => this.#registry.unregister(p));
+    this.#map.forEach((ref) => this.#registry.unregister(ref));
     this.#map.clear();
   }
   forEach(callbackfn, thisArg) {
@@ -96,16 +100,17 @@ class KindaWeakMap {
     }
   }
   get size() {
-    return this.#map.size;
+    return this.entries().reduce((count) => count + 1, 0);
   }
   entries() {
-    return this.#map.entries().map(([key, ref]) => [key, ref.deref()]);
+    const held = this.#map.entries().map(([key, ref]) => [key, ref.deref()]);
+    return held.filter((entry) => entry[1] !== undefined);
   }
   keys() {
-    return this.#map.keys();
+    return this.entries().map(([key]) => key);
   }
   values() {
-    return this.#map.values().map((ref) => ref.deref());
+    return this.entries().map(([, value]) => value);
   }
   [Symbol.iterator]() {
     return this.entries();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhombus-toolkit/collections",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Collection data structures: ImmutableLinkedList (persistent, both ends known), KindaWeakMap (strong keys, weak values).",
   "repository": {
     "type": "git",