@pyreon/reactivity 0.24.5 → 0.24.6

package/src/tests/createSelector.test.ts

@@ -1,291 +0,0 @@
-import { createSelector } from '../createSelector'
-import { effect } from '../effect'
-import { signal } from '../signal'
-
-describe('createSelector', () => {
-  test('returns true for the currently selected value', () => {
-    const selected = signal(1)
-    const isSelected = createSelector(() => selected())
-
-    let result = false
-    effect(() => {
-      result = isSelected(1)
-    })
-    expect(result).toBe(true)
-  })
-
-  test('returns false for non-selected values', () => {
-    const selected = signal(1)
-    const isSelected = createSelector(() => selected())
-
-    let result = true
-    effect(() => {
-      result = isSelected(2)
-    })
-    expect(result).toBe(false)
-  })
-
-  test('only notifies affected subscribers when selection changes', () => {
-    const selected = signal(1)
-    const isSelected = createSelector(() => selected())
-
-    let runs1 = 0
-    let runs2 = 0
-    let runs3 = 0
-
-    effect(() => {
-      isSelected(1)
-      runs1++
-    })
-    effect(() => {
-      isSelected(2)
-      runs2++
-    })
-    effect(() => {
-      isSelected(3)
-      runs3++
-    })
-
-    expect(runs1).toBe(1)
-    expect(runs2).toBe(1)
-    expect(runs3).toBe(1)
-
-    // Change selection from 1 to 2: only buckets 1 (deselected) and 2 (newly selected) should fire
-    selected.set(2)
-    expect(runs1).toBe(2) // deselected
-    expect(runs2).toBe(2) // newly selected
-    expect(runs3).toBe(1) // unaffected
-  })
-
-  test('does not notify when source changes to the same value', () => {
-    const selected = signal(1)
-    const isSelected = createSelector(() => selected())
-
-    let runs = 0
-    effect(() => {
-      isSelected(1)
-      runs++
-    })
-
-    selected.set(1) // same value
-    expect(runs).toBe(1)
-  })
-
-  test('works when changing to a value with no subscribers', () => {
-    const selected = signal(1)
-    const isSelected = createSelector(() => selected())
-
-    let runs = 0
-    effect(() => {
-      isSelected(1)
-      runs++
-    })
-
-    // Change to value 99 which has no subscriber bucket
-    selected.set(99)
-    expect(runs).toBe(2) // old bucket (1) notified
-  })
-
-  test('reuses host objects for the same value', () => {
-    const selected = signal(1)
-    const isSelected = createSelector(() => selected())
-
-    let result1 = false
-    let result2 = false
-    effect(() => {
-      result1 = isSelected(1)
-    })
-    // Second call with same value should reuse the host
-    effect(() => {
-      result2 = isSelected(1)
-    })
-
-    expect(result1).toBe(true)
-    expect(result2).toBe(true)
-
-    selected.set(2)
-    expect(result1).toBe(false)
-    expect(result2).toBe(false)
-  })
-
-  test('tracks correctly outside an effect (no activeEffect)', () => {
-    const selected = signal(1)
-    const isSelected = createSelector(() => selected())
-
-    // Calling outside an effect should still return the correct boolean
-    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)
-    })
-  })
-
-  // Regression: pre-fix, the source-tracking effect ran forever AND the
-  // per-value subs/hosts Maps grew unboundedly. With dynamic value spaces
-  // (UUIDs, ephemeral IDs) this leaked memory for the lifetime of the
-  // program. dispose() now stops the effect AND clears both Maps.
-  describe('dispose', () => {
-    test('stops source-tracking after dispose', () => {
-      const selected = signal(0)
-      const isSelected = createSelector(() => selected())
-      const runs: number[] = []
-      effect(() => {
-        runs.push(isSelected(1) ? 1 : 0)
-      })
-      expect(runs).toEqual([0])
-      selected.set(1)
-      expect(runs).toEqual([0, 1])
-
-      isSelected.dispose()
-      // Source change after dispose — the effect that tracks `isSelected(1)`
-      // should NOT re-run because the selector's internal effect was stopped.
-      selected.set(2)
-      expect(runs).toEqual([0, 1])
-    })
-
-    test('post-dispose calls return last-known result without tracking', () => {
-      const selected = signal(0)
-      const isSelected = createSelector(() => selected())
-      isSelected.dispose()
-      // Last known value was 0 — calls return its match against the query.
-      expect(isSelected(0)).toBe(true)
-      expect(isSelected(1)).toBe(false)
-    })
-
-    test('dispose is idempotent', () => {
-      const selected = signal(0)
-      const isSelected = createSelector(() => selected())
-      expect(() => {
-        isSelected.dispose()
-        isSelected.dispose()
-        isSelected.dispose()
-      }).not.toThrow()
-    })
-
-    test('post-dispose: source no longer propagates to selector', () => {
-      // Observable consequence of stopping the internal effect — proves
-      // the per-value Maps are no longer being populated either (because
-      // the tracking path is bypassed entirely after dispose).
-      const selected = signal('initial')
-      const isSelected = createSelector(() => selected())
-      // Build up the cache by querying many unique values.
-      for (let i = 0; i < 100; i++) isSelected(`uuid-${i}`)
-      isSelected.dispose()
-      // After dispose, the source is no longer tracked — changing it
-      // doesn't propagate to the selector's internal `current` value.
-      selected.set('changed')
-      expect(isSelected('initial')).toBe(true) // last-known wins
-      expect(isSelected('changed')).toBe(false) // never propagated
-    })
-  })
-})

package/src/tests/debug.test.ts

@@ -1,196 +0,0 @@
-import { _notifyTraceListeners, inspectSignal, isTracing, onSignalUpdate, why } from '../debug'
-import { signal } from '../signal'
-
-describe('debug', () => {
-  describe('onSignalUpdate / isTracing', () => {
-    test('isTracing is false by default', () => {
-      expect(isTracing()).toBe(false)
-    })
-
-    test('registering a listener enables tracing', () => {
-      const dispose = onSignalUpdate(() => {})
-      expect(isTracing()).toBe(true)
-      dispose()
-      expect(isTracing()).toBe(false)
-    })
-
-    test('listener receives signal update events', () => {
-      const events: { name: string | undefined; prev: unknown; next: unknown }[] = []
-      const dispose = onSignalUpdate((e) => {
-        events.push({ name: e.name, prev: e.prev, next: e.next })
-      })
-
-      const s = signal(1, { name: 'count' })
-      s.set(2)
-
-      expect(events.length).toBe(1)
-      expect(events[0]).toEqual({ name: 'count', prev: 1, next: 2 })
-
-      dispose()
-    })
-
-    test('dispose removes only the specific listener', () => {
-      let calls1 = 0
-      let calls2 = 0
-      const dispose1 = onSignalUpdate(() => calls1++)
-      const dispose2 = onSignalUpdate(() => calls2++)
-
-      const s = signal(0)
-      s.set(1)
-      expect(calls1).toBe(1)
-      expect(calls2).toBe(1)
-
-      dispose1()
-
-      s.set(2)
-      expect(calls1).toBe(1) // removed
-      expect(calls2).toBe(2) // still active
-
-      dispose2()
-      expect(isTracing()).toBe(false)
-    })
-
-    test('dispose is safe to call when listeners already null', () => {
-      const dispose = onSignalUpdate(() => {})
-      dispose()
-      expect(isTracing()).toBe(false)
-      dispose() // should not throw — _traceListeners is null
-    })
-
-    test('_notifyTraceListeners does nothing when no listeners', () => {
-      const s = signal(0)
-      // Should not throw
-      _notifyTraceListeners(s, 0, 1)
-    })
-
-    test('event includes stack and timestamp', () => {
-      let event: { stack: string; timestamp: number } | undefined
-      const dispose = onSignalUpdate((e) => {
-        event = { stack: e.stack, timestamp: e.timestamp }
-      })
-
-      const s = signal(0)
-      s.set(1)
-
-      expect(event).toBeDefined()
-      expect(typeof event?.stack).toBe('string')
-      expect(typeof event?.timestamp).toBe('number')
-
-      dispose()
-    })
-  })
-
-  describe('why', () => {
-    test('logs signal updates to console', async () => {
-      const logs: unknown[][] = []
-      const origLog = console.log
-      console.log = (...args: unknown[]) => logs.push(args)
-
-      const s = signal(1, { name: 'test' })
-      why()
-      s.set(2)
-
-      // Wait for microtask (auto-dispose)
-      await new Promise((r) => queueMicrotask(() => r(undefined)))
-
-      expect(logs.length).toBeGreaterThan(0)
-      console.log = origLog
-    })
-
-    test("logs 'no updates' when nothing changes", async () => {
-      const logs: unknown[][] = []
-      const origLog = console.log
-      console.log = (...args: unknown[]) => logs.push(args)
-
-      why()
-      // No signal updates
-
-      await new Promise((r) => queueMicrotask(() => r(undefined)))
-
-      const noUpdateLog =
-        logs.find((args) =>
-          typeof args[0] === 'string' ? args[0].includes('No signal') : false,
-        ) ||
-        logs.find((args) => (typeof args[1] === 'string' ? args[1].includes('No signal') : false))
-      expect(noUpdateLog).toBeDefined()
-      console.log = origLog
-    })
-
-    test('calling why() twice is ignored (already active)', async () => {
-      const logs: unknown[][] = []
-      const origLog = console.log
-      console.log = (...args: unknown[]) => logs.push(args)
-
-      why()
-      why() // should be ignored
-      const s = signal(0, { name: 'x' })
-      s.set(1)
-
-      await new Promise((r) => queueMicrotask(() => r(undefined)))
-      // Should not throw or double-log
-      console.log = origLog
-    })
-
-    test('logs anonymous signal name when no name is set', async () => {
-      const logs: unknown[][] = []
-      const origLog = console.log
-      console.log = (...args: unknown[]) => logs.push(args)
-
-      const s = signal(0) // no name
-      why()
-      s.set(1)
-
-      await new Promise((r) => queueMicrotask(() => r(undefined)))
-
-      const anonLog = logs.find((args) =>
-        args.some((a) => typeof a === 'string' && a.includes('anonymous')),
-      )
-      expect(anonLog).toBeDefined()
-      console.log = origLog
-    })
-  })
-
-  describe('inspectSignal', () => {
-    test('prints signal info and returns debug info', () => {
-      const groupCalls: unknown[][] = []
-      const logCalls: unknown[][] = []
-      const origGroup = console.group
-      const origLog = console.log
-      const origEnd = console.groupEnd
-      console.group = (...args: unknown[]) => groupCalls.push(args)
-      console.log = (...args: unknown[]) => logCalls.push(args)
-      console.groupEnd = () => {}
-
-      const s = signal(42, { name: 'count' })
-      const info = inspectSignal(s)
-
-      expect(info.name).toBe('count')
-      expect(info.value).toBe(42)
-      expect(info.subscriberCount).toBe(0)
-      expect(groupCalls.length).toBe(1)
-      expect(logCalls.length).toBe(2) // value + subscribers
-
-      console.group = origGroup
-      console.log = origLog
-      console.groupEnd = origEnd
-    })
-
-    test('handles anonymous signal', () => {
-      const origGroup = console.group
-      const origLog = console.log
-      const origEnd = console.groupEnd
-      console.group = () => {}
-      console.log = () => {}
-      console.groupEnd = () => {}
-
-      const s = signal(0)
-      const info = inspectSignal(s)
-
-      expect(info.name).toBeUndefined()
-
-      console.group = origGroup
-      console.log = origLog
-      console.groupEnd = origEnd
-    })
-  })
-})