Fix infinite loop in Map#iterator

packages/arbor-store/src/handlers/map.ts

@@ -11,10 +11,11 @@ export class MapHandler<T extends object = object> extends DefaultHandler<
   }
 
   *[Symbol.iterator]() {
-    if (!isNode<Map<unknown, T>>(this)) throw new NotAnArborNodeError()
+    const mapProxy = this.$tree.getNodeFor(this) as unknown as Map<unknown, T>
 
-    for (const entry of this.entries()) {
-      yield entry
+    for (const entry of this.$value.entries()) {
+      const childProxy = mapProxy.get(entry[0])
+      yield [entry[0], childProxy]
     }
   }
 

packages/arbor-store/src/scoping/scope.ts

@@ -125,6 +125,10 @@ export class Scope<T extends object> {
           return target
         }
 
+        // TODO: handlers/map.ts must intercept child access so it can proxy them
+        // otherwise, accessing a child from a scoped map will not yield a scoped
+        // child but the actual underlying value.
+
         const child = Reflect.get(target, prop, proxy)
         const descriptor = Object.getOwnPropertyDescriptor(target, prop)
 

packages/arbor-store/tests/scoping/map.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest"
+import { Arbor } from "../../src/arbor"
+import { ScopedStore } from "../../src/scoping/store"
+
+describe("map", () => {
+  describe("Symbol.iterator", () => {
+    it("can convert a map node from a scoped store to array", () => {
+      const store = new Arbor(
+        new Map([
+          [1, "Alice"],
+          [2, "Bob"],
+        ])
+      )
+
+      const scope = new ScopedStore(store)
+      const list = Array.from(scope.state)
+
+      expect(list).toEqual([
+        [1, "Alice"],
+        [2, "Bob"],
+      ])
+    })
+
+    it.skip("exposes scoped nodes", () => {
+      const bob = { name: "Bob" }
+      const alice = { name: "Alice" }
+      const store = new Arbor(
+        new Map([
+          [1, alice],
+          [2, bob],
+        ])
+      )
+
+      const scope = new ScopedStore(store)
+      const list = Array.from(scope.state)
+
+      expect(list[0][1]).toBeNodeOf(alice)
+      expect(list[1][1]).toBeNodeOf(bob)
+      expect(list[0][1]).toBeTrackedNode()
+      expect(list[1][1]).toBeTrackedNode()
+    })
+  })
+})