meh

Author: samthor

package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.83",
+  "version": "1.1.84",
   "devDependencies": {
     "@types/ws": "^8.5.13",
     "esbuild": "^0.23.0",

src/memory.ts

@@ -1,3 +1,6 @@
+/**
+ * Internal node mostly for {@link WeakIdentityCache}, although has nothing to do with {@link WeakRef}.
+ */
 class TupleNode {
   private hasValue = false;
   private value?: any | undefined;
@@ -115,6 +118,29 @@ export class WeakIdentityCache<K extends [...any], V extends WeakKey> {
     });
   }
 
+  /**
+   * Provides a {@link V} for the given {@link K}.
+   * This allows you to skip the builder, however, this {@link K} will still be passed to the cleanup function when it is GC'ed.
+   *
+   * If this {@link K} already has a value, rejects the update and returns `false`.
+   * Otherwise, returns `true`.
+   */
+  provide(v: V, ...k: K): boolean {
+    const wr = this.#root.get(k);
+    let curr = wr?.deref();
+    if (curr !== undefined) {
+      return false;
+    }
+
+    curr = v;
+    const update = new WeakRef(curr);
+    this.#root.set(k, update);
+    this.#reg.register(curr, k, curr);
+    this.#count++;
+
+    return true;
+  }
+
   /**
    * Gets this {@link K} from the cache.
    *
@@ -123,15 +149,16 @@ export class WeakIdentityCache<K extends [...any], V extends WeakKey> {
   get(...k: K): V {
     const wr = this.#root.get(k);
     let curr = wr?.deref();
-
-    if (curr === undefined) {
-      curr = this.#build(...k);
-      const update = new WeakRef(curr);
-      this.#root.set(k, update);
-      this.#reg.register(curr, k, curr);
-      this.#count++;
+    if (curr !== undefined) {
+      return curr;
     }
 
+    curr = this.#build(...k);
+    const update = new WeakRef(curr);
+    this.#root.set(k, update);
+    this.#reg.register(curr, k, curr);
+    this.#count++;
+
     return curr;
   }
 
@@ -156,8 +183,9 @@ export class WeakIdentityCache<K extends [...any], V extends WeakKey> {
 
   /**
    * Deletes this {@link K} from the cache.
+   * Returns `true` if it existed and was deleted.
    *
-   * This will prevent it from being passed to the cleanup function.
+   * This will prevent the given {@link K} from being passed to the cleanup function.
    */
   delete(...k: K): boolean {
     const wr = this.#root.get(k);
@@ -176,7 +204,20 @@ export class WeakIdentityCache<K extends [...any], V extends WeakKey> {
     return false;
   }
 
+  /**
+   * Gets the current size of actual values.
+   *
+   * This is useful for testing but might change as things are GC'ed.
+   */
   get size() {
     return this.#count;
   }
 }
+
+/**
+ * Builds a helper which provides shared named symbols.
+ */
+export function buildScopedSymbolCache(id: string): (s: string) => Symbol {
+  const cache = new WeakIdentityCache<[string], Symbol>((s) => Symbol(`${id}:${s}`));
+  return cache.get.bind(cache);
+}

src/rope.ts

@@ -684,7 +684,7 @@ export class Rope<K, T = void> {
   /**
    * Iterate from after the given ID, to the target ID inclusive (i.e., `(afterId,untilId]`).
    *
-   * If no `untilId` is passed or the IDs are in the wrong order, iterates from after `afterId` until the end of this {@link Rope.}.
+   * If no `untilId` is passed or the IDs are in the wrong order, iterates from after `afterId` until the end of this {@link Rope}.
    */
   *iter(
     afterId: K = this._zeroId,

test/memory.ts

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import * as assert from 'node:assert';
-import { WeakIdentityCache } from '../src/memory.ts';
+import { buildScopedSymbolCache, WeakIdentityCache } from '../src/memory.ts';
 import { checkGC } from './support/node.ts';
 
 class Blah {}
@@ -66,3 +66,19 @@ test('under', () => {
   assert.strictEqual(c.all(2, 'hello').length, 2);
   assert.strictEqual(c.all(2, 'hello', 'x').length, 0);
 });
+
+test('symbol', async () => {
+  const s = buildScopedSymbolCache('blah');
+
+  let x1 = s('x1');
+  let x2 = s('x2');
+
+  assert.notStrictEqual(x1, x2);
+  assert.strictEqual(x1, s('x1'));
+  assert.strictEqual(x2, s('x2'));
+
+  await Promise.resolve();
+
+  assert.strictEqual(x1, s('x1'));
+  assert.strictEqual(x2, s('x2'));
+});