@rhombus-toolkit/collections 2.0.1 → 2.1.0

package/dist/bundle/index.d.ts

@@ -1,3 +1,22 @@
+/**
+ * A stack whose entries leave when their scope does.
+ *
+ * @remarks
+ * Iterates outermost first.
+ */
+declare class AutoStack<T> implements Iterable<T> {
+    #private;
+    /** How many entries the stack holds. */
+    get length(): number;
+    /** Adds `item`; disposing the return truncates back to the pre-push depth, so an outer scope's dispose also drops what an inner one left. */
+    push(item: T): Disposable;
+    /** Whether `item` sits anywhere in the stack, not only at the top. */
+    has(item: T): boolean;
+    /** The innermost entry, absent where the stack holds nothing. */
+    peek(): T | undefined;
+    [Symbol.iterator](): ArrayIterator<T>;
+}
+
 /**
  * A persistent singly-linked list — extending shares everything already there.
  *
@@ -30,6 +49,7 @@ declare class ImmutableLinkedList<T> implements Iterable<T> {
 
 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;
@@ -45,4 +65,4 @@ declare class KindaWeakMap<K, V extends WeakKey> {
     readonly [Symbol.toStringTag]: "KindaWeakMap";
 }
 
-export { ImmutableLinkedList, KindaWeakMap };
+export { AutoStack, ImmutableLinkedList, KindaWeakMap };

package/dist/bundle/index.js

@@ -1,3 +1,26 @@
+// src/AutoStack.ts
+class AutoStack {
+  #items = [];
+  get length() {
+    return this.#items.length;
+  }
+  push(item) {
+    const pos = this.#items.length;
+    this.#items.push(item);
+    return { [Symbol.dispose]: () => {
+      this.#items.length = pos;
+    } };
+  }
+  has(item) {
+    return this.#items.includes(item);
+  }
+  peek() {
+    return this.#items.at(-1);
+  }
+  [Symbol.iterator]() {
+    return this.#items.values();
+  }
+}
 // src/ImmutableLinkedList.ts
 class ImmutableLinkedList {
   static #nothing = new ImmutableLinkedList(undefined, undefined, 0);
@@ -60,25 +83,29 @@ 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) {
-    this.delete(key);
-    this.#registry.register(value, key, value);
-    this.#map.set(key, new WeakRef(value));
+    const held = this.#map.get(key);
+    if (held) {
+      this.#registry.unregister(held);
+    }
+    const ref = new WeakRef(value);
+    this.#registry.register(value, { key, ref }, ref);
+    this.#map.set(key, ref);
     return this;
   }
   delete(key) {
-    const value = this.get(key);
-    this.#map.delete(key);
-    if (value === undefined) {
+    const held = this.#map.get(key);
+    if (!held) {
       return false;
     }
-    this.#registry.unregister(value);
-    return true;
+    this.#map.delete(key);
+    this.#registry.unregister(held);
+    return held.deref() !== undefined;
   }
   get(key) {
     return this.#map.get(key)?.deref();
@@ -87,7 +114,7 @@ class KindaWeakMap {
     return this.get(key) !== undefined;
   }
   clear() {
-    this.values().forEach((value) => this.#registry.unregister(value));
+    this.#map.forEach((ref) => this.#registry.unregister(ref));
     this.#map.clear();
   }
   forEach(callbackfn, thisArg) {
@@ -114,6 +141,7 @@ class KindaWeakMap {
   [Symbol.toStringTag] = "KindaWeakMap";
 }
 export {
+  AutoStack,
   ImmutableLinkedList,
   KindaWeakMap
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rhombus-toolkit/collections",
-  "version": "2.0.1",
-  "description": "Collection data structures: ImmutableLinkedList (persistent, both ends known), KindaWeakMap (strong keys, weak values).",
+  "version": "2.1.0",
+  "description": "Collection data structures: AutoStack (entries leave with their scope), ImmutableLinkedList (persistent, both ends known), KindaWeakMap (strong keys, weak values).",
   "repository": {
     "type": "git",
     "url": "https://github.com/rhombus-toolkit/ts.git",