@pyreon/reactivity 0.7.12 → 0.7.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/reactivity",
-  "version": "0.7.12",
+  "version": "0.7.13",
   "description": "Signals-based reactivity system for Pyreon",
   "license": "MIT",
   "repository": {

package/src/tests/computed.test.ts

@@ -197,4 +197,123 @@ describe("computed", () => {
     s.set(11) // clamped to 10, same as before
     expect(called).toBe(2) // equals suppresses
   })
+
+  describe("_v with equals after disposal", () => {
+    test("_v returns last cached value after dispose()", () => {
+      const s = signal(5)
+      const doubled = computed(() => s() * 2)
+      expect(doubled._v).toBe(10) // triggers initial computation
+
+      s.set(7)
+      expect(doubled._v).toBe(14) // recomputes
+
+      doubled.dispose()
+      s.set(100)
+      // After dispose, _v returns the last cached value (14)
+      // because dirty flag is not set (no subscription) and the
+      // disposed guard prevents recomputation
+      expect(doubled._v).toBe(14)
+    })
+
+    test("computed with equals: _v only updates when equality check fails", () => {
+      const s = signal(3)
+      const floored = computed(() => Math.floor(s() / 10), {
+        equals: (a, b) => a === b,
+      })
+
+      expect(floored._v).toBe(0) // Math.floor(3/10) = 0
+
+      s.set(5) // Math.floor(5/10) = 0, same
+      expect(floored._v).toBe(0)
+
+      s.set(15) // Math.floor(15/10) = 1, different
+      expect(floored._v).toBe(1)
+
+      s.set(19) // Math.floor(19/10) = 1, same
+      expect(floored._v).toBe(1)
+    })
+
+    test("multiple .direct() updaters on computed, dispose one", () => {
+      const s = signal(1)
+      const doubled = computed(() => s() * 2)
+      doubled() // initialize
+
+      let calls1 = 0
+      let calls2 = 0
+      let calls3 = 0
+
+      const dispose1 = doubled.direct(() => {
+        calls1++
+      })
+      doubled.direct(() => {
+        calls2++
+      })
+      doubled.direct(() => {
+        calls3++
+      })
+
+      s.set(2)
+      expect(calls1).toBe(1)
+      expect(calls2).toBe(1)
+      expect(calls3).toBe(1)
+
+      dispose1()
+      // Read to reset dirty flag so next change triggers recompute notification
+      doubled()
+      s.set(3)
+      expect(calls1).toBe(1) // disposed
+      expect(calls2).toBe(2) // still active
+      expect(calls3).toBe(2) // still active
+    })
+  })
+
+  describe("diamond pattern cleanup", () => {
+    test("a -> b, c -> d diamond: d only recomputes once per a change", () => {
+      const a = signal(1)
+      const b = computed(() => a() + 1)
+      const c = computed(() => a() + 2)
+
+      let dComputations = 0
+      const d = computed(() => {
+        dComputations++
+        return b() + c()
+      })
+
+      expect(d()).toBe(5) // b=2 + c=3
+      expect(dComputations).toBe(1)
+
+      a.set(2) // b=3, c=4
+      expect(d()).toBe(7)
+      // d should only recompute once (lazy evaluation avoids double recompute)
+      expect(dComputations).toBe(2)
+    })
+
+    test("dispose middle node in diamond, verify no stale subscriptions", () => {
+      const a = signal(1)
+      const b = computed(() => a() * 2)
+      const c = computed(() => a() * 3)
+
+      let dRuns = 0
+      const d = computed(() => {
+        dRuns++
+        return b() + c()
+      })
+
+      expect(d()).toBe(5) // b=2 + c=3
+      expect(dRuns).toBe(1)
+
+      // Dispose b — it will no longer recompute from a
+      b.dispose()
+
+      a.set(2)
+      // d still recomputes because c changed, but b returns stale value (2)
+      expect(d()).toBe(8) // b=2 (stale) + c=6
+      expect(dRuns).toBe(2)
+
+      // Verify a no longer notifies b's subscribers
+      a.set(3)
+      expect(d()).toBe(11) // b=2 (still stale) + c=9
+      expect(dRuns).toBe(3)
+    })
+  })
 })

package/src/tests/createSelector.test.ts

@@ -116,4 +116,117 @@ describe("createSelector", () => {
     expect(isSelected(1)).toBe(true)
     expect(isSelected(2)).toBe(false)
   })
+
+  describe("large subscriber sets", () => {
+    test("many subscribers (20+), only affected buckets notified", () => {
+      const selected = signal(0)
+      const isSelected = createSelector(() => selected())
+
+      const runCounts: number[] = []
+      for (let i = 0; i < 25; i++) {
+        const idx = i
+        runCounts.push(0)
+        effect(() => {
+          isSelected(idx)
+          runCounts[idx] = (runCounts[idx] ?? 0) + 1
+        })
+      }
+
+      // All effects ran once
+      const allOnes = runCounts.every((c) => c === 1)
+      expect(allOnes).toBe(true)
+
+      // Change from 0 to 5: only buckets 0 and 5 should re-run
+      selected.set(5)
+      expect(runCounts[0]).toBe(2) // deselected
+      expect(runCounts[5]).toBe(2) // newly selected
+      const unaffectedAfterFirst = runCounts.every((c, i) => i === 0 || i === 5 || c === 1)
+      expect(unaffectedAfterFirst).toBe(true)
+
+      // Change from 5 to 24: only buckets 5 and 24 re-run
+      selected.set(24)
+      expect(runCounts[5]).toBe(3)
+      expect(runCounts[24]).toBe(2)
+      const unaffectedAfterSecond = runCounts.every((c, i) => [0, 5, 24].includes(i) || c === 1)
+      expect(unaffectedAfterSecond).toBe(true)
+    })
+
+    test("selector with undefined and null values", () => {
+      const selected = signal<string | null | undefined>("a")
+      const isSelected = createSelector(() => selected())
+
+      let nullRuns = 0
+      let undefRuns = 0
+      let aRuns = 0
+
+      effect(() => {
+        isSelected(null)
+        nullRuns++
+      })
+      effect(() => {
+        isSelected(undefined)
+        undefRuns++
+      })
+      effect(() => {
+        isSelected("a")
+        aRuns++
+      })
+
+      expect(nullRuns).toBe(1)
+      expect(undefRuns).toBe(1)
+      expect(aRuns).toBe(1)
+
+      // Switch to null
+      selected.set(null)
+      expect(aRuns).toBe(2) // deselected
+      expect(nullRuns).toBe(2) // newly selected
+      expect(undefRuns).toBe(1) // unaffected
+
+      // Switch to undefined
+      selected.set(undefined)
+      expect(nullRuns).toBe(3) // deselected
+      expect(undefRuns).toBe(2) // newly selected
+      expect(aRuns).toBe(2) // unaffected
+    })
+
+    test("rapid selector changes", () => {
+      const selected = signal(0)
+      const isSelected = createSelector(() => selected())
+
+      let runs0 = 0
+      let runs1 = 0
+      let runs2 = 0
+
+      effect(() => {
+        isSelected(0)
+        runs0++
+      })
+      effect(() => {
+        isSelected(1)
+        runs1++
+      })
+      effect(() => {
+        isSelected(2)
+        runs2++
+      })
+
+      // Rapid changes: 0 -> 1 -> 2 -> 0
+      selected.set(1)
+      selected.set(2)
+      selected.set(0)
+
+      // Each affected bucket should have been notified for each change
+      // 0->1: runs0+1, runs1+1
+      // 1->2: runs1+1, runs2+1
+      // 2->0: runs2+1, runs0+1
+      expect(runs0).toBe(3) // initial + deselected + reselected
+      expect(runs1).toBe(3) // initial + selected + deselected
+      expect(runs2).toBe(3) // initial + selected + deselected
+
+      // Final state
+      expect(isSelected(0)).toBe(true)
+      expect(isSelected(1)).toBe(false)
+      expect(isSelected(2)).toBe(false)
+    })
+  })
 })

package/src/tests/signal.test.ts

@@ -117,4 +117,62 @@ describe("signal", () => {
     const info = s.debug()
     expect(info.name).toBeUndefined()
   })
+
+  describe("direct updater disposal", () => {
+    test("disposed direct updater is not called on subsequent updates", () => {
+      const s = signal(0)
+      let called = 0
+      const dispose = s.direct(() => {
+        called++
+      })
+
+      s.set(1)
+      expect(called).toBe(1)
+
+      dispose()
+      s.set(2)
+      expect(called).toBe(1) // not called after disposal
+    })
+
+    test("multiple direct updaters, dispose one, others still fire", () => {
+      const s = signal(0)
+      let calls1 = 0
+      let calls2 = 0
+      let calls3 = 0
+
+      const dispose1 = s.direct(() => {
+        calls1++
+      })
+      s.direct(() => {
+        calls2++
+      })
+      s.direct(() => {
+        calls3++
+      })
+
+      s.set(1)
+      expect(calls1).toBe(1)
+      expect(calls2).toBe(1)
+      expect(calls3).toBe(1)
+
+      dispose1()
+      s.set(2)
+      expect(calls1).toBe(1) // disposed — not called
+      expect(calls2).toBe(2) // still active
+      expect(calls3).toBe(2) // still active
+    })
+
+    test("direct updater slot is null after disposal", () => {
+      const s = signal(0)
+      const dispose = s.direct(() => {})
+
+      // Access internal _d array via cast
+      const internal = s as unknown as { _d: ((() => void) | null)[] | null }
+      expect(internal._d).not.toBeNull()
+      expect(internal._d![0]).toBeTypeOf("function")
+
+      dispose()
+      expect(internal._d![0]).toBeNull()
+    })
+  })
 })