@pyreon/reactivity 0.24.5 → 0.24.6

package/src/tests/effect.test.ts

@@ -1,464 +0,0 @@
-import { effect, onCleanup, renderEffect, setErrorHandler } from '../effect'
-import { effectScope, setCurrentScope } from '../scope'
-import { signal } from '../signal'
-
-describe('effect', () => {
-  test('runs immediately', () => {
-    let ran = false
-    effect(() => {
-      ran = true
-    })
-    expect(ran).toBe(true)
-  })
-
-  test('re-runs when tracked signal changes', () => {
-    const s = signal(0)
-    let count = 0
-    effect(() => {
-      s() // track
-      count++
-    })
-    expect(count).toBe(1)
-    s.set(1)
-    expect(count).toBe(2)
-    s.set(2)
-    expect(count).toBe(3)
-  })
-
-  test('does not re-run after dispose', () => {
-    const s = signal(0)
-    let count = 0
-    const e = effect(() => {
-      s()
-      count++
-    })
-    e.dispose()
-    s.set(1)
-    expect(count).toBe(1) // only the initial run
-  })
-
-  test('tracks multiple signals', () => {
-    const a = signal(1)
-    const b = signal(2)
-    let result = 0
-    effect(() => {
-      result = a() + b()
-    })
-    expect(result).toBe(3)
-    a.set(10)
-    expect(result).toBe(12)
-    b.set(20)
-    expect(result).toBe(30)
-  })
-
-  test('does not track signals accessed after conditional branch', () => {
-    const toggle = signal(true)
-    const a = signal(1)
-    const b = signal(100)
-    let result = 0
-    effect(() => {
-      result = toggle() ? a() : b()
-    })
-    expect(result).toBe(1)
-    a.set(2)
-    expect(result).toBe(2)
-    toggle.set(false)
-    expect(result).toBe(100)
-    // a is no longer tracked
-    a.set(999)
-    expect(result).toBe(100)
-  })
-
-  test('catches errors via default error handler', () => {
-    const errors: unknown[] = []
-    const origError = console.error
-    console.error = (...args: unknown[]) => errors.push(args)
-
-    const s = signal(0)
-    effect(() => {
-      s()
-      throw new Error('boom')
-    })
-
-    expect(errors.length).toBe(1)
-    console.error = origError
-  })
-
-  test('calls cleanup before re-run', () => {
-    const s = signal(0)
-    let cleanups = 0
-    effect(() => {
-      s()
-      return () => {
-        cleanups++
-      }
-    })
-    expect(cleanups).toBe(0)
-    s.set(1) // re-run: previous cleanup fires
-    expect(cleanups).toBe(1)
-    s.set(2)
-    expect(cleanups).toBe(2)
-  })
-
-  test('calls cleanup on dispose', () => {
-    const s = signal(0)
-    let cleanups = 0
-    const e = effect(() => {
-      s()
-      return () => {
-        cleanups++
-      }
-    })
-    expect(cleanups).toBe(0)
-    e.dispose()
-    expect(cleanups).toBe(1)
-    // Disposing again should not call cleanup again
-    e.dispose()
-    expect(cleanups).toBe(1)
-  })
-
-  test('cleanup errors are caught by error handler', () => {
-    const caught: unknown[] = []
-    setErrorHandler((err) => caught.push(err))
-
-    const s = signal(0)
-    effect(() => {
-      s()
-      return () => {
-        throw new Error('cleanup boom')
-      }
-    })
-    s.set(1) // triggers cleanup which throws
-    expect(caught.length).toBe(1)
-    expect((caught[0] as Error).message).toBe('cleanup boom')
-
-    // Restore default handler
-    setErrorHandler((_err) => {})
-  })
-
-  test('works with no cleanup return (backwards compatible)', () => {
-    const s = signal(0)
-    let count = 0
-    effect(() => {
-      s()
-      count++
-      // no return
-    })
-    expect(count).toBe(1)
-    s.set(1)
-    expect(count).toBe(2)
-  })
-
-  test('setErrorHandler replaces the error handler', () => {
-    const caught: unknown[] = []
-    setErrorHandler((err) => caught.push(err))
-
-    const s = signal(0)
-    effect(() => {
-      s()
-      throw new Error('custom')
-    })
-
-    expect(caught.length).toBe(1)
-    expect((caught[0] as Error).message).toBe('custom')
-
-    // Restore default handler
-    setErrorHandler((_err) => {})
-  })
-
-  test('effect notifies scope on re-run (not first run)', async () => {
-    const scope = effectScope()
-    setCurrentScope(scope)
-
-    let updateCount = 0
-    scope.addUpdateHook(() => {
-      updateCount++
-    })
-
-    const s = signal(0)
-    effect(() => {
-      s()
-    })
-
-    setCurrentScope(null)
-
-    expect(updateCount).toBe(0) // first run does not notify
-
-    s.set(1) // re-run triggers notifyEffectRan
-    await new Promise((r) => setTimeout(r, 10))
-    expect(updateCount).toBe(1)
-
-    scope.stop()
-  })
-})
-
-describe('renderEffect', () => {
-  test('runs immediately and tracks signals', () => {
-    const s = signal(0)
-    let count = 0
-    renderEffect(() => {
-      s()
-      count++
-    })
-    expect(count).toBe(1)
-    s.set(1)
-    expect(count).toBe(2)
-  })
-
-  test('dispose stops tracking', () => {
-    const s = signal(0)
-    let count = 0
-    const dispose = renderEffect(() => {
-      s()
-      count++
-    })
-    expect(count).toBe(1)
-    dispose()
-    s.set(1)
-    expect(count).toBe(1)
-  })
-
-  test('dispose is idempotent', () => {
-    const s = signal(0)
-    const dispose = renderEffect(() => {
-      s()
-    })
-    dispose()
-    dispose() // should not throw
-  })
-
-  test('tracks dynamic dependencies', () => {
-    const toggle = signal(true)
-    const a = signal(1)
-    const b = signal(100)
-    let result = 0
-    renderEffect(() => {
-      result = toggle() ? a() : b()
-    })
-    expect(result).toBe(1)
-    toggle.set(false)
-    expect(result).toBe(100)
-    a.set(999) // no longer tracked
-    expect(result).toBe(100)
-  })
-
-  test('does not re-run after disposed during signal update', () => {
-    const s = signal(0)
-    let count = 0
-    const dispose = renderEffect(() => {
-      s()
-      count++
-    })
-    dispose()
-    s.set(5)
-    expect(count).toBe(1)
-  })
-})
-
-describe('onCleanup', () => {
-  test('runs cleanup before effect re-runs', () => {
-    const s = signal(0)
-    const log: string[] = []
-    effect(() => {
-      const val = s()
-      onCleanup(() => log.push(`cleanup-${val}`))
-      log.push(`run-${val}`)
-    })
-    expect(log).toEqual(['run-0'])
-    s.set(1)
-    expect(log).toEqual(['run-0', 'cleanup-0', 'run-1'])
-    s.set(2)
-    expect(log).toEqual(['run-0', 'cleanup-0', 'run-1', 'cleanup-1', 'run-2'])
-  })
-
-  test('runs cleanup on dispose', () => {
-    let cleaned = false
-    const e = effect(() => {
-      onCleanup(() => {
-        cleaned = true
-      })
-    })
-    expect(cleaned).toBe(false)
-    e.dispose()
-    expect(cleaned).toBe(true)
-  })
-
-  test('supports multiple onCleanup calls', () => {
-    const s = signal(0)
-    const log: string[] = []
-    effect(() => {
-      s()
-      onCleanup(() => log.push('a'))
-      onCleanup(() => log.push('b'))
-    })
-    s.set(1)
-    expect(log).toEqual(['a', 'b'])
-  })
-
-  test('works alongside return cleanup', () => {
-    const s = signal(0)
-    const log: string[] = []
-    effect(() => {
-      s()
-      onCleanup(() => log.push('onCleanup'))
-      return () => log.push('return')
-    })
-    s.set(1)
-    expect(log).toEqual(['onCleanup', 'return'])
-  })
-
-  test('no-ops outside effect', () => {
-    // Should not throw
-    onCleanup(() => {})
-  })
-
-  test('cleanup ordering: onCleanup runs before return cleanup', () => {
-    const s = signal(0)
-    const log: string[] = []
-    effect(() => {
-      const val = s()
-      onCleanup(() => log.push(`onCleanup-${val}`))
-      return () => log.push(`return-${val}`)
-    })
-    s.set(1)
-    // onCleanup should fire first, then return cleanup
-    expect(log).toEqual(['onCleanup-0', 'return-0'])
-    s.set(2)
-    expect(log).toEqual(['onCleanup-0', 'return-0', 'onCleanup-1', 'return-1'])
-  })
-
-  test('multiple onCleanup callbacks run in registration order', () => {
-    const s = signal(0)
-    const log: string[] = []
-    effect(() => {
-      s()
-      onCleanup(() => log.push('first'))
-      onCleanup(() => log.push('second'))
-      onCleanup(() => log.push('third'))
-    })
-    s.set(1)
-    expect(log).toEqual(['first', 'second', 'third'])
-  })
-
-  test('cleanup runs on dispose even when effect never re-ran', () => {
-    const log: string[] = []
-    const e = effect(() => {
-      onCleanup(() => log.push('disposed'))
-    })
-    expect(log).toEqual([])
-    e.dispose()
-    expect(log).toEqual(['disposed'])
-  })
-})
-
-describe('effect — error handling', () => {
-  test('error in effect does not prevent other effects from running', () => {
-    const caught: unknown[] = []
-    setErrorHandler((err) => caught.push(err))
-
-    const s = signal(0)
-    let goodEffectRuns = 0
-
-    effect(() => {
-      s()
-      throw new Error('bad effect')
-    })
-    effect(() => {
-      s()
-      goodEffectRuns++
-    })
-
-    expect(caught).toHaveLength(1)
-    expect(goodEffectRuns).toBe(1)
-
-    s.set(1)
-    expect(caught).toHaveLength(2)
-    expect(goodEffectRuns).toBe(2)
-
-    setErrorHandler((_err) => {})
-  })
-
-  test('error during cleanup is caught by error handler', () => {
-    const caught: unknown[] = []
-    setErrorHandler((err) => caught.push(err))
-
-    const s = signal(0)
-    effect(() => {
-      s()
-      onCleanup(() => {
-        throw new Error('cleanup error')
-      })
-    })
-
-    s.set(1) // triggers cleanup which throws
-    expect(caught).toHaveLength(1)
-    expect((caught[0] as Error).message).toBe('cleanup error')
-
-    setErrorHandler((_err) => {})
-  })
-})
-
-// ─── Audit bug #1: async effect runtime warning ──────────────────────────────
-//
-// Companion to the `pyreon/no-async-effect` lint rule. The runtime warn
-// catches the case where the lint rule was suppressed or the effect call
-// site was constructed dynamically (e.g. via a higher-order helper that
-// the lint rule's static check doesn't see).
-
-describe('effect — async function warning (audit bug #1)', () => {
-  test('warns when called with an async arrow function', () => {
-    const warns: string[] = []
-    const orig = console.warn
-    console.warn = (...args: unknown[]) => warns.push(args.join(' '))
-    try {
-      // Async effect callbacks are intentionally NOT in `effect()`'s type
-      // signature — that's the point. The test deliberately misuses the
-      // API to verify the runtime warning catches what the type system
-      // would normally reject. Cast through `unknown` to silence TS.
-      const asyncFn = async (): Promise<void> => {}
-      effect(asyncFn as unknown as () => void)
-    } finally {
-      console.warn = orig
-    }
-    expect(warns.some((m) => m.includes('async function'))).toBe(true)
-    expect(warns.some((m) => m.includes('await'))).toBe(true)
-  })
-
-  test('does NOT warn for synchronous effect callbacks', () => {
-    const warns: string[] = []
-    const orig = console.warn
-    console.warn = (...args: unknown[]) => warns.push(args.join(' '))
-    try {
-      effect(() => {})
-    } finally {
-      console.warn = orig
-    }
-    expect(warns.some((m) => m.includes('async function'))).toBe(false)
-  })
-
-  test('renderEffect warns when called with an async arrow function', () => {
-    const warns: string[] = []
-    const orig = console.warn
-    console.warn = (...args: unknown[]) => warns.push(args.join(' '))
-    try {
-      const asyncFn = async (): Promise<void> => {}
-      renderEffect(asyncFn as unknown as () => void)
-    } finally {
-      console.warn = orig
-    }
-    expect(warns.some((m) => m.includes('renderEffect'))).toBe(true)
-    expect(warns.some((m) => m.includes('async function'))).toBe(true)
-  })
-
-  test('renderEffect does NOT warn for synchronous callbacks', () => {
-    const warns: string[] = []
-    const orig = console.warn
-    console.warn = (...args: unknown[]) => warns.push(args.join(' '))
-    try {
-      renderEffect(() => {})
-    } finally {
-      console.warn = orig
-    }
-    expect(warns.some((m) => m.includes('async function'))).toBe(false)
-  })
-})

package/src/tests/fanout-repro.test.ts

@@ -1,179 +0,0 @@
-/**
- * Reproduction of the deferred bug from PR #490 (queryReactiveKey-1000 journey).
- *
- * Symptom from real-app stress: a `reactKey` signal subscribed to by ~100
- * effects (each useQuery's setOptions effect) sees `signalWrite` increment
- * on every `.set(i)` in a tight external loop, but only 1 of N effect runs
- * propagates per .set — `effectRun` stays at the initial-mount count.
- *
- * Hypothesis to test: `notifySubscribers` in tracking.ts iterates the live
- * Set with `originalSize` cap. If an effect's body calls cleanupEffect (which
- * removes itself from the Set) AND re-subscribes (adds itself back at the
- * end), the iteration order shifts so subsequent effects' positions move
- * BEFORE `i`, causing them to be skipped on this pass.
- *
- * See packages/core/reactivity/src/tracking.ts:77-105 (notifySubscribers).
- */
-import { describe, expect, it } from 'vitest'
-import { effect, effectScope, signal } from '../index'
-
-describe('signal fan-out under tight external write loop', () => {
-  it('100 effects subscribing to same signal — each fires on every external .set', () => {
-    const sig = signal(0)
-    const counts = new Array(100).fill(0)
-
-    for (let i = 0; i < 100; i++) {
-      const idx = i
-      effect(() => {
-        sig() // subscribe
-        counts[idx]++
-      })
-    }
-
-    // Each effect ran ONCE at registration.
-    for (const c of counts) expect(c).toBe(1)
-
-    // 10 external writes from outside any batch.
-    for (let i = 1; i <= 10; i++) sig.set(i)
-
-    // Each effect should have re-fired 10 times → total = 11.
-    for (let i = 0; i < counts.length; i++) {
-      expect(counts[i], `effect[${i}] runs after 10 sets`).toBe(11)
-    }
-  })
-
-  it('1 effect — fires on every external .set (control)', () => {
-    const sig = signal(0)
-    let count = 0
-
-    effect(() => {
-      sig()
-      count++
-    })
-
-    expect(count).toBe(1)
-    for (let i = 1; i <= 10; i++) sig.set(i)
-    expect(count).toBe(11)
-  })
-
-  it('5 effects + 5 external sets — each effect fires per set', () => {
-    const sig = signal(0)
-    const counts = new Array(5).fill(0)
-
-    for (let i = 0; i < 5; i++) {
-      const idx = i
-      effect(() => {
-        sig()
-        counts[idx]++
-      })
-    }
-
-    for (let i = 1; i <= 5; i++) sig.set(i)
-
-    // Each effect: 1 initial + 5 re-runs = 6.
-    for (let i = 0; i < counts.length; i++) {
-      expect(counts[i], `effect[${i}]`).toBe(6)
-    }
-  })
-
-  it('100 effects inside an EffectScope — each fires on every external .set', () => {
-    const sig = signal(0)
-    const counts = new Array(100).fill(0)
-    const scope = effectScope()
-
-    scope.runInScope(() => {
-      for (let i = 0; i < 100; i++) {
-        const idx = i
-        effect(() => {
-          sig()
-          counts[idx]++
-        })
-      }
-    })
-
-    for (const c of counts) expect(c).toBe(1)
-
-    for (let i = 1; i <= 10; i++) sig.set(i)
-
-    for (let i = 0; i < counts.length; i++) {
-      expect(counts[i], `effect[${i}] runs after 10 sets`).toBe(11)
-    }
-  })
-
-  it('1000 effects subscribing to same signal — each fires per .set', () => {
-    const sig = signal(0)
-    const counts = new Array(1000).fill(0)
-    for (let i = 0; i < 1000; i++) {
-      const idx = i
-      effect(() => {
-        sig()
-        counts[idx]++
-      })
-    }
-    for (let i = 1; i <= 10; i++) sig.set(i)
-    let failed = 0
-    for (let i = 0; i < counts.length; i++) {
-      if (counts[i] !== 11) failed++
-    }
-    expect(failed, `effects with wrong count`).toBe(0)
-  })
-
-  it('effects created INSIDE another effect run (inner-effect collector path)', () => {
-    const trigger = signal(0)
-    const sig = signal(0)
-    const counts = new Array(50).fill(0)
-    let outerRuns = 0
-
-    // Outer effect creates 50 INNER effects on each run.
-    effect(() => {
-      trigger()
-      outerRuns++
-      for (let i = 0; i < 50; i++) {
-        const idx = i
-        effect(() => {
-          sig()
-          counts[idx]++
-        })
-      }
-    })
-
-    // Reset counts after initial outer run created the inners with their initial run.
-    expect(outerRuns).toBe(1)
-    for (const c of counts) expect(c).toBe(1)
-
-    // Now flip sig 10 times — every inner should fire 10 more times.
-    for (let i = 1; i <= 10; i++) sig.set(i)
-
-    let failed = 0
-    for (let i = 0; i < counts.length; i++) {
-      if (counts[i] !== 11) failed++
-    }
-    expect(failed, `inner effects with wrong count`).toBe(0)
-  })
-
-  it('100 effects whose body writes to an unrelated signal during run', () => {
-    // Mirrors useQuery's effect: body calls observer.setOptions(options())
-    // which fires the observer's subscribe callback, which calls batch()
-    // and writes to N "result slot" signals (which may have 0 or N subscribers).
-    const sig = signal(0)
-    const slot = signal('')
-    const counts = new Array(100).fill(0)
-
-    for (let i = 0; i < 100; i++) {
-      const idx = i
-      effect(() => {
-        sig() // subscribe to sig
-        // Simulate observer.setOptions's downstream subscribe-callback work:
-        // an inner write to a different signal that has no subscribers.
-        slot.set(`run-${idx}`) // 100 different values, each Object.is fails
-        counts[idx]++
-      })
-    }
-
-    for (let i = 1; i <= 10; i++) sig.set(i)
-
-    for (let i = 0; i < counts.length; i++) {
-      expect(counts[i], `effect[${i}] runs after 10 sets`).toBe(11)
-    }
-  })
-})