@pyreon/reactivity 0.24.5 → 0.24.6

package/src/tests/tracking.test.ts

@@ -1,158 +0,0 @@
-import { batch } from '../batch'
-import { effect, renderEffect } from '../effect'
-import { signal } from '../signal'
-import { runUntracked } from '../tracking'
-
-describe('tracking', () => {
-  describe('notifySubscribers', () => {
-    test('multi-subscriber notification without batching (snapshot path)', () => {
-      const s = signal(0)
-      let runs1 = 0
-      let runs2 = 0
-
-      effect(() => {
-        s()
-        runs1++
-      })
-      effect(() => {
-        s()
-        runs2++
-      })
-
-      expect(runs1).toBe(1)
-      expect(runs2).toBe(1)
-
-      // Triggers non-batched multi-subscriber path (snapshot via [...subscribers])
-      s.set(1)
-      expect(runs1).toBe(2)
-      expect(runs2).toBe(2)
-    })
-
-    test('multi-subscriber notification during batching', () => {
-      const s = signal(0)
-      let runs1 = 0
-      let runs2 = 0
-
-      effect(() => {
-        s()
-        runs1++
-      })
-      effect(() => {
-        s()
-        runs2++
-      })
-
-      batch(() => {
-        s.set(1)
-      })
-
-      expect(runs1).toBe(2)
-      expect(runs2).toBe(2)
-    })
-
-    test('single subscriber batching path', () => {
-      const s = signal(0)
-      let runs = 0
-
-      effect(() => {
-        s()
-        runs++
-      })
-
-      batch(() => {
-        s.set(1)
-      })
-
-      expect(runs).toBe(2)
-    })
-  })
-
-  describe('runUntracked', () => {
-    test('signal reads inside runUntracked do not create dependencies', () => {
-      const s = signal(0)
-      let runs = 0
-
-      effect(() => {
-        runUntracked(() => s())
-        runs++
-      })
-
-      expect(runs).toBe(1)
-      s.set(1)
-      expect(runs).toBe(1) // not re-run
-    })
-
-    test('restores tracking context after runUntracked', () => {
-      const tracked = signal(0)
-      const untracked = signal(0)
-      let runs = 0
-
-      effect(() => {
-        tracked()
-        runUntracked(() => untracked())
-        runs++
-      })
-
-      expect(runs).toBe(1)
-
-      // tracked signal should still trigger re-run
-      tracked.set(1)
-      expect(runs).toBe(2)
-
-      // untracked signal should not
-      untracked.set(1)
-      expect(runs).toBe(2)
-    })
-  })
-
-  describe('trackSubscriber with depsCollector', () => {
-    test('renderEffect uses fast deps collector path', () => {
-      const s = signal(0)
-      let runs = 0
-
-      const dispose = renderEffect(() => {
-        s()
-        runs++
-      })
-
-      s.set(1)
-      expect(runs).toBe(2)
-
-      dispose()
-      s.set(2)
-      expect(runs).toBe(2)
-    })
-  })
-
-  describe('cleanupEffect', () => {
-    test('effect dynamically tracks/untracks deps on re-run', () => {
-      const cond = signal(true)
-      const a = signal(0)
-      const b = signal(0)
-      let runs = 0
-
-      effect(() => {
-        if (cond()) {
-          a()
-        } else {
-          b()
-        }
-        runs++
-      })
-
-      expect(runs).toBe(1)
-
-      a.set(1) // tracked
-      expect(runs).toBe(2)
-
-      cond.set(false) // switch branch
-      expect(runs).toBe(3)
-
-      a.set(2) // no longer tracked
-      expect(runs).toBe(3)
-
-      b.set(1) // now tracked
-      expect(runs).toBe(4)
-    })
-  })
-})

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

@@ -1,191 +0,0 @@
-// 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()
-  })
-})

package/src/tests/watch.test.ts

@@ -1,246 +0,0 @@
-import { signal } from '../signal'
-import { watch } from '../watch'
-
-describe('watch', () => {
-  test('calls callback when source changes', () => {
-    const s = signal(1)
-    const calls: [number, number | undefined][] = []
-
-    watch(
-      () => s(),
-      (newVal, oldVal) => {
-        calls.push([newVal, oldVal])
-      },
-    )
-
-    expect(calls.length).toBe(0) // not called on first run without immediate
-
-    s.set(2)
-    expect(calls).toEqual([[2, 1]])
-
-    s.set(3)
-    expect(calls).toEqual([
-      [2, 1],
-      [3, 2],
-    ])
-  })
-
-  test('immediate option calls callback on first run', () => {
-    const s = signal(1)
-    const calls: [number, number | undefined][] = []
-
-    watch(
-      () => s(),
-      (newVal, oldVal) => {
-        calls.push([newVal, oldVal])
-      },
-      { immediate: true },
-    )
-
-    expect(calls).toEqual([[1, undefined]])
-  })
-
-  test('stop function disposes the watcher', () => {
-    const s = signal(1)
-    let callCount = 0
-
-    const stop = watch(
-      () => s(),
-      () => {
-        callCount++
-      },
-    )
-
-    s.set(2)
-    expect(callCount).toBe(1)
-
-    stop()
-
-    s.set(3)
-    expect(callCount).toBe(1) // no more calls
-  })
-
-  test('cleanup function is called before each re-run', () => {
-    const s = signal(1)
-    const log: string[] = []
-
-    watch(
-      () => s(),
-      (newVal) => {
-        log.push(`run-${newVal}`)
-        return () => log.push(`cleanup-${newVal}`)
-      },
-    )
-
-    s.set(2)
-    expect(log).toEqual(['run-2'])
-
-    s.set(3)
-    expect(log).toEqual(['run-2', 'cleanup-2', 'run-3'])
-  })
-
-  test('cleanup function from immediate is called on next change', () => {
-    const s = signal(1)
-    const log: string[] = []
-
-    watch(
-      () => s(),
-      (newVal) => {
-        log.push(`run-${newVal}`)
-        return () => log.push(`cleanup-${newVal}`)
-      },
-      { immediate: true },
-    )
-
-    expect(log).toEqual(['run-1'])
-
-    s.set(2)
-    expect(log).toEqual(['run-1', 'cleanup-1', 'run-2'])
-  })
-
-  test('cleanup is called on stop', () => {
-    const s = signal(1)
-    const log: string[] = []
-
-    const stop = watch(
-      () => s(),
-      (newVal) => {
-        log.push(`run-${newVal}`)
-        return () => log.push(`cleanup-${newVal}`)
-      },
-    )
-
-    s.set(2)
-    expect(log).toEqual(['run-2'])
-
-    stop()
-    expect(log).toEqual(['run-2', 'cleanup-2'])
-  })
-
-  test('callback returning non-function does not set cleanup', () => {
-    const s = signal(1)
-    let callCount = 0
-
-    watch(
-      () => s(),
-      () => {
-        callCount++
-        // returns void, not a function
-      },
-    )
-
-    s.set(2)
-    s.set(3)
-    expect(callCount).toBe(2)
-  })
-
-  test('stop without cleanup does not throw', () => {
-    const s = signal(1)
-    const stop = watch(
-      () => s(),
-      () => {},
-    )
-
-    stop() // no cleanup function was set, should not throw
-  })
-
-  test('oldValue tracks previous value across multiple changes', () => {
-    const s = signal('a')
-    const history: [string, string | undefined][] = []
-
-    watch(
-      () => s(),
-      (newVal, oldVal) => {
-        history.push([newVal, oldVal])
-      },
-    )
-
-    s.set('b')
-    s.set('c')
-    s.set('d')
-
-    expect(history).toEqual([
-      ['b', 'a'],
-      ['c', 'b'],
-      ['d', 'c'],
-    ])
-  })
-
-  test('oldValue is undefined on immediate first call', () => {
-    const s = signal(42)
-    let receivedOld: number | undefined = -1
-
-    watch(
-      () => s(),
-      (_newVal, oldVal) => {
-        receivedOld = oldVal
-      },
-      { immediate: true },
-    )
-
-    expect(receivedOld).toBeUndefined()
-  })
-
-  test('watch with derived source (computed-like)', () => {
-    const a = signal(1)
-    const b = signal(10)
-    const calls: [number, number | undefined][] = []
-
-    watch(
-      () => a() + b(),
-      (newVal, oldVal) => {
-        calls.push([newVal, oldVal])
-      },
-    )
-
-    a.set(2) // 2 + 10 = 12
-    expect(calls).toEqual([[12, 11]])
-
-    b.set(20) // 2 + 20 = 22
-    expect(calls).toEqual([
-      [12, 11],
-      [22, 12],
-    ])
-  })
-
-  test('stop prevents cleanup from running on future changes', () => {
-    const s = signal(1)
-    const log: string[] = []
-
-    const stop = watch(
-      () => s(),
-      (newVal) => {
-        log.push(`run-${newVal}`)
-        return () => log.push(`cleanup-${newVal}`)
-      },
-    )
-
-    s.set(2)
-    expect(log).toEqual(['run-2'])
-
-    stop()
-    expect(log).toEqual(['run-2', 'cleanup-2'])
-
-    // Further changes should not trigger anything
-    s.set(3)
-    expect(log).toEqual(['run-2', 'cleanup-2'])
-  })
-
-  test('watch does not fire when value stays the same', () => {
-    const s = signal(1)
-    let callCount = 0
-
-    watch(
-      () => s(),
-      () => {
-        callCount++
-      },
-    )
-
-    s.set(1) // same value — signal doesn't notify
-    expect(callCount).toBe(0)
-
-    s.set(2)
-    expect(callCount).toBe(1)
-  })
-})