@pyreon/reactivity 0.15.0 → 0.18.0

package/src/tests/resource.test.ts

@@ -230,4 +230,97 @@ describe('createResource', () => {
     await new Promise((r) => setTimeout(r, 10))
     expect(results).toEqual(['user-1', 'user-5', 'user-5'])
   })
+
+  // Regression: pre-fix, the source-tracking effect ran forever with no API
+  // to stop it. Resources created outside an EffectScope leaked the effect
+  // for the lifetime of the program. dispose() now stops the effect AND
+  // marks pending in-flight responses as stale.
+  describe('dispose', () => {
+    test('stops source-tracking after dispose', async () => {
+      const src = signal(1)
+      const calls: number[] = []
+      const resource = createResource(
+        () => src(),
+        (id) => {
+          calls.push(id)
+          return Promise.resolve(`user-${id}`)
+        },
+      )
+
+      await new Promise((r) => setTimeout(r, 10))
+      expect(calls).toEqual([1])
+
+      resource.dispose()
+
+      // Source change after dispose — should NOT trigger a new fetch.
+      src.set(2)
+      await new Promise((r) => setTimeout(r, 10))
+      expect(calls).toEqual([1])
+    })
+
+    test('refetch is a no-op after dispose', async () => {
+      const src = signal(1)
+      const calls: number[] = []
+      const resource = createResource(
+        () => src(),
+        (id) => {
+          calls.push(id)
+          return Promise.resolve(`user-${id}`)
+        },
+      )
+
+      await new Promise((r) => setTimeout(r, 10))
+      expect(calls).toEqual([1])
+
+      resource.dispose()
+      resource.refetch()
+      await new Promise((r) => setTimeout(r, 10))
+      expect(calls).toEqual([1])
+    })
+
+    test('in-flight response is discarded after dispose', async () => {
+      const src = signal(1)
+      // Capture the resolver via a one-element holder so TS doesn't narrow
+      // the closure-assigned variable to `never` after the new Promise
+      // callback returns. `let r = null` then assignment inside the
+      // callback narrows to `never` post-callback (no follow-callback flow).
+      const holder: { resolve: (v: string) => void } = {
+        resolve: () => undefined,
+      }
+      const resource = createResource(
+        () => src(),
+        () =>
+          new Promise<string>((r) => {
+            holder.resolve = r
+          }),
+      )
+
+      // Don't resolve yet — fetch is in flight.
+      expect(resource.loading()).toBe(true)
+      resource.dispose()
+
+      // Now resolve — handlers should see the bumped requestId and discard.
+      holder.resolve('late-result')
+      await new Promise((r) => setTimeout(r, 10))
+
+      expect(resource.data()).toBeUndefined()
+      // loading was true at dispose; response was discarded so the
+      // post-fetch `loading.set(false)` never ran. That's the documented
+      // contract — dispose freezes the resource at its current state.
+      expect(resource.loading()).toBe(true)
+    })
+
+    test('dispose is idempotent', () => {
+      const src = signal(1)
+      const resource = createResource(
+        () => src(),
+        (id) => Promise.resolve(`user-${id}`),
+      )
+      expect(() => {
+        resource.dispose()
+        resource.dispose()
+        resource.dispose()
+      }).not.toThrow()
+    })
+  })
 })

package/src/tests/scope.test.ts

@@ -199,4 +199,33 @@ describe('effectScope', () => {
     expect(errors.length).toBe(1)
     console.error = origError
   })
+
+  // Regression: pre-fix, addUpdateHook always allocated `_updateHooks` and
+  // pushed the fn even after `stop()`. The fn never fired (because
+  // notifyEffectRan checks `_active` first), but the registration leaked
+  // an array allocation and gave the caller no signal that the hook was
+  // futile. Mirrors `add()`'s silent-no-op-when-stopped contract.
+  test('addUpdateHook honors _active — silently no-ops on stopped scope', () => {
+    const scope = effectScope()
+    scope.stop()
+
+    let hookFired = false
+    scope.addUpdateHook(() => {
+      hookFired = true
+    })
+
+    // Cause an update — the hook should NOT fire because scope is stopped.
+    scope.notifyEffectRan()
+    expect(hookFired).toBe(false)
+
+    // The internal `_updateHooks` should not have been allocated either.
+    // We can't introspect the private field, but the observable contract
+    // is "stopped scopes don't fire hooks under any circumstance" — which
+    // would have held pre-fix too because `notifyEffectRan` already
+    // gated on `_active`. The fix prevents the array allocation; we test
+    // the consequence: no fire, regardless of how often you push.
+    for (let i = 0; i < 100; i++) scope.addUpdateHook(() => {})
+    scope.notifyEffectRan()
+    expect(hookFired).toBe(false)
+  })
 })

package/src/tests/signal.test.ts

@@ -1,4 +1,5 @@
 import { batch } from '../batch'
+import { onSignalUpdate } from '../debug'
 import { effect } from '../effect'
 import { signal } from '../signal'
 
@@ -231,4 +232,111 @@ describe('signal', () => {
       warnSpy.mockRestore()
     })
   })
+
+  // Regression: pre-fix, a throwing trace listener (registered via
+  // onSignalUpdate) was called inline between the `_v` write and subscriber
+  // notification. If it threw, `_v` was updated but no effects ran — divergent
+  // state. Fix wraps the trace dispatch in try/catch.
+  describe('throwing trace listener does not corrupt state', () => {
+    test('subscribers still fire when a trace listener throws', () => {
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+      const s = signal(0)
+      const subscriberRuns: number[] = []
+      effect(() => {
+        subscriberRuns.push(s())
+      })
+
+      const dispose = onSignalUpdate(() => {
+        throw new Error('trace listener boom')
+      })
+
+      // Pre-fix: the throwing listener would prevent the subscriber from
+      // firing. Post-fix: the listener throws, gets logged, subscriber runs.
+      s.set(5)
+      expect(subscriberRuns).toEqual([0, 5])
+      // Dev mode logs the listener error — bisect-verify the wrap is in place
+      expect(errorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('trace listener threw'),
+        expect.any(Error),
+      )
+
+      dispose()
+      errorSpy.mockRestore()
+    })
+
+    test('multiple writes survive a chronically-broken listener', () => {
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+      const s = signal(0)
+      const seen: number[] = []
+      effect(() => {
+        seen.push(s())
+      })
+
+      const dispose = onSignalUpdate(() => {
+        throw new Error('always')
+      })
+      s.set(1)
+      s.set(2)
+      s.set(3)
+      expect(seen).toEqual([0, 1, 2, 3])
+
+      dispose()
+      errorSpy.mockRestore()
+    })
+  })
+
+  // L7 audit gap: cap-iteration in notifySubscribers caps at originalSize to
+  // avoid infinite loops if a subscriber re-inserts itself or others into the
+  // Set. The contract: subscribers added DURING notification fire next round,
+  // not this round (no double-fire). Pin the contract.
+  describe('subscriber cap-iteration during notification (L7)', () => {
+    test('subscriber added mid-notification fires on the NEXT write, not the current one', () => {
+      const s = signal(0)
+      const fires: string[] = []
+
+      const lateSubscriber = (): void => {
+        fires.push('late')
+      }
+
+      s.subscribe(() => {
+        fires.push('first')
+        // Add a NEW subscriber during the notification. Per cap-iteration
+        // contract, it should NOT fire this round.
+        s.subscribe(lateSubscriber)
+      })
+
+      s.set(1)
+      // Only "first" fires this round — "late" gets registered, doesn't run.
+      expect(fires).toEqual(['first'])
+
+      // Next write — both fire (first was already there, late is now registered).
+      fires.length = 0
+      s.set(2)
+      expect(fires.sort()).toEqual(['first', 'late'])
+    })
+
+    test('subscriber that disposes itself mid-iteration cleans up cleanly', () => {
+      const s = signal(0)
+      let disposeMe: (() => void) | null = null
+      let firstRuns = 0
+      let secondRuns = 0
+
+      s.subscribe(() => {
+        firstRuns++
+      })
+      disposeMe = s.subscribe(() => {
+        secondRuns++
+        disposeMe?.() // self-dispose
+      })
+
+      s.set(1)
+      expect(firstRuns).toBe(1)
+      expect(secondRuns).toBe(1)
+
+      // Next write — second is gone, first still fires.
+      s.set(2)
+      expect(firstRuns).toBe(2)
+      expect(secondRuns).toBe(1)
+    })
+  })
 })

package/src/tests/store.test.ts

@@ -143,6 +143,60 @@ describe('createStore', () => {
     expect(bValues).toEqual([2, undefined])
   })
 
+  // Regression: delete-then-reassign cycle. Pre-fix `deleteProperty` removed
+  // the entry from `propSignals`, so a later `set` on the same key created a
+  // FRESH signal — but every effect that previously read the key was tracked
+  // against the OLD signal, which had been dropped. Effects never re-ran on
+  // the reassign. Fix keeps the signal in `propSignals`, and `get` short-
+  // circuits to the existing signal when the key isn't `hasOwn` but a tracked
+  // signal exists. See store.ts (deleteProperty, get).
+  test('delete-then-reassign re-runs effects (signal identity preserved)', () => {
+    const state = createStore({ a: 1, b: 2 } as Record<string, number | undefined>)
+    const bValues: (number | undefined)[] = []
+    effect(() => {
+      bValues.push(state.b)
+    })
+    expect(bValues).toEqual([2])
+    delete state.b
+    expect(bValues).toEqual([2, undefined])
+    state.b = 99
+    expect(bValues).toEqual([2, undefined, 99])
+    // Cycle a second time to lock the contract — same signal identity reused.
+    delete state.b
+    state.b = 7
+    expect(bValues).toEqual([2, undefined, 99, undefined, 7])
+  })
+
+  // Regression: built-in objects with internal slots (Map, Set, Date, …) used
+  // to be wrapped in the proxy, which broke their methods (`Map.prototype.set`
+  // called on a Proxy → `TypeError: incompatible receiver`). Fix returns the
+  // raw instance from `wrap()` for these types — no fine-grained reactivity
+  // for their contents, but they're at least usable. See store.ts
+  // (isBuiltinNonProxiable).
+  test('Map fields are returned raw, not wrapped (proxy-incompatible)', () => {
+    const state = createStore({ users: new Map<string, number>() })
+    expect(() => state.users.set('alice', 1)).not.toThrow()
+    expect(state.users.get('alice')).toBe(1)
+    expect(state.users.size).toBe(1)
+  })
+
+  test('Set fields are returned raw, not wrapped', () => {
+    const state = createStore({ tags: new Set<string>() })
+    expect(() => state.tags.add('foo')).not.toThrow()
+    expect(state.tags.has('foo')).toBe(true)
+  })
+
+  test('Date fields are returned raw, not wrapped', () => {
+    const d = new Date('2026-01-01')
+    const state = createStore({ created: d })
+    expect(state.created.getFullYear()).toBe(2026)
+  })
+
+  test('RegExp fields are returned raw, not wrapped', () => {
+    const state = createStore({ rx: /abc/ })
+    expect(state.rx.test('abc')).toBe(true)
+  })
+
   test('setting array length directly triggers reactivity', () => {
     const state = createStore({ items: [1, 2, 3, 4, 5] })
     const lengths: number[] = []

package/src/tests/vue-parity.test.ts

@@ -0,0 +1,191 @@
+// Tests for the Vue-parity APIs added in M4: markRaw, shallowReactive,
+// onScopeDispose. Each surface is independent; grouped here for legibility
+// rather than spreading across signal/store/scope test files.
+
+import { effect } from '../effect'
+import { effectScope, getCurrentScope, onScopeDispose } from '../scope'
+import { signal } from '../signal'
+import { createStore, markRaw, shallowReactive } from '../store'
+
+describe('markRaw', () => {
+  test('marks an object as raw — createStore returns it unwrapped', () => {
+    const raw = markRaw({ x: 1 })
+    const store = createStore({ inner: raw })
+    // Reading store.inner returns the raw reference, not a proxy.
+    expect(store.inner).toBe(raw)
+    // Mutating raw does NOT trigger reactivity (it's not proxied).
+    let runs = 0
+    effect(() => {
+      void store.inner.x
+      runs++
+    })
+    expect(runs).toBe(1)
+    raw.x = 99
+    expect(runs).toBe(1) // not reactive — raw bypasses proxy
+  })
+
+  test('also opts out of shallowReactive wrapping', () => {
+    const raw = markRaw({ y: 2 })
+    const store = shallowReactive({ inner: raw })
+    expect(store.inner).toBe(raw)
+  })
+
+  test('class instances marked raw are usable without proxy quirks', () => {
+    class Editor {
+      cursor = 0
+      moveTo(pos: number): void {
+        this.cursor = pos
+      }
+    }
+    const ed = markRaw(new Editor())
+    const store = createStore({ editor: ed })
+    expect(() => store.editor.moveTo(5)).not.toThrow()
+    expect(store.editor.cursor).toBe(5)
+    expect(store.editor).toBe(ed) // identity preserved
+  })
+
+  test('markRaw is idempotent', () => {
+    const obj = { x: 1 }
+    expect(() => {
+      markRaw(obj)
+      markRaw(obj)
+    }).not.toThrow()
+  })
+})
+
+describe('shallowReactive', () => {
+  test('top-level mutations trigger reactivity', () => {
+    const store = shallowReactive({ count: 0 })
+    let seen = -1
+    effect(() => {
+      seen = store.count
+    })
+    expect(seen).toBe(0)
+    store.count = 5
+    expect(seen).toBe(5)
+  })
+
+  test('nested mutations do NOT trigger reactivity (shallow)', () => {
+    const store = shallowReactive({ user: { name: 'Alice' } })
+    let runs = 0
+    effect(() => {
+      void store.user.name
+      runs++
+    })
+    expect(runs).toBe(1)
+    // Nested mutation — should NOT re-run because nested object is raw.
+    store.user.name = 'Bob'
+    expect(runs).toBe(1)
+  })
+
+  test('replacing a top-level reference DOES trigger reactivity', () => {
+    const store = shallowReactive({ user: { name: 'Alice' } })
+    const names: string[] = []
+    effect(() => {
+      names.push(store.user.name)
+    })
+    expect(names).toEqual(['Alice'])
+    store.user = { name: 'Bob' }
+    expect(names).toEqual(['Alice', 'Bob'])
+  })
+
+  test('nested reads return raw references, not proxies', () => {
+    const inner = { x: 1 }
+    const store = shallowReactive({ inner })
+    expect(store.inner).toBe(inner)
+  })
+
+  test('separate cache from createStore — same raw can be both shallow and deep', () => {
+    const raw = { x: 1 }
+    const deep = createStore(raw)
+    const shallow = shallowReactive({ wrapper: raw })
+    // The shallow store returns raw nested, not the deep proxy.
+    expect(shallow.wrapper).toBe(raw)
+    // The deep store wraps raw.
+    expect(deep).not.toBe(raw)
+  })
+})
+
+describe('onScopeDispose', () => {
+  test('callback fires when scope stops', () => {
+    const scope = effectScope()
+    let disposed = 0
+    scope.runInScope(() => {
+      onScopeDispose(() => {
+        disposed++
+      })
+    })
+    expect(disposed).toBe(0)
+    scope.stop()
+    expect(disposed).toBe(1)
+  })
+
+  test('multiple callbacks all fire, in registration order', () => {
+    const scope = effectScope()
+    const order: string[] = []
+    scope.runInScope(() => {
+      onScopeDispose(() => order.push('first'))
+      onScopeDispose(() => order.push('second'))
+      onScopeDispose(() => order.push('third'))
+    })
+    scope.stop()
+    expect(order).toEqual(['first', 'second', 'third'])
+  })
+
+  test('warns when called outside any scope (dev mode)', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    let called = false
+    onScopeDispose(() => {
+      called = true
+    })
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('without an active EffectScope'),
+    )
+    expect(called).toBe(false)
+    warnSpy.mockRestore()
+  })
+
+  test('captures the SCOPE active at registration time', () => {
+    const scopeA = effectScope()
+    const scopeB = effectScope()
+    const log: string[] = []
+    scopeA.runInScope(() => {
+      onScopeDispose(() => log.push('A'))
+    })
+    scopeB.runInScope(() => {
+      onScopeDispose(() => log.push('B'))
+    })
+    scopeA.stop()
+    expect(log).toEqual(['A'])
+    scopeB.stop()
+    expect(log).toEqual(['A', 'B'])
+  })
+
+  test('integrates with effect lifecycle — disposes alongside scope effects', () => {
+    const s = signal(0)
+    const scope = effectScope()
+    const events: string[] = []
+    scope.runInScope(() => {
+      effect(() => {
+        events.push(`effect:${s()}`)
+      })
+      onScopeDispose(() => events.push('disposed'))
+    })
+    s.set(1)
+    expect(events).toEqual(['effect:0', 'effect:1'])
+    scope.stop()
+    expect(events).toEqual(['effect:0', 'effect:1', 'disposed'])
+    s.set(2)
+    // Both effect and dispose callback are inactive after stop.
+    expect(events).toEqual(['effect:0', 'effect:1', 'disposed'])
+  })
+
+  test('captures null-scope correctly — no-op without throwing', () => {
+    expect(getCurrentScope()).toBeNull()
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    expect(() => {
+      onScopeDispose(() => {})
+    }).not.toThrow()
+    warnSpy.mockRestore()
+  })
+})