@pyreon/reactivity 0.24.5 → 0.24.6

package/src/tests/signal.test.ts

@@ -1,368 +0,0 @@
-import { batch } from '../batch'
-import { onSignalUpdate } from '../debug'
-import { effect } from '../effect'
-import { signal } from '../signal'
-
-describe('signal', () => {
-  test('reads initial value', () => {
-    const s = signal(42)
-    expect(s()).toBe(42)
-  })
-
-  test('set updates value', () => {
-    const s = signal(0)
-    s.set(10)
-    expect(s()).toBe(10)
-  })
-
-  test('update transforms value', () => {
-    const s = signal(5)
-    s.update((n) => n * 2)
-    expect(s()).toBe(10)
-  })
-
-  test('set with same value does not notify', () => {
-    const s = signal(1)
-    let calls = 0
-    effect(() => {
-      s() // track
-      calls++
-    })
-    expect(calls).toBe(1) // initial run
-    s.set(1) // same value — no notification
-    expect(calls).toBe(1)
-    s.set(2) // different value — notifies
-    expect(calls).toBe(2)
-  })
-
-  test('works with objects', () => {
-    const s = signal({ x: 1 })
-    s.update((o) => ({ ...o, x: 2 }))
-    expect(s().x).toBe(2)
-  })
-
-  test('works with null and undefined', () => {
-    const s = signal<string | null>(null)
-    expect(s()).toBeNull()
-    s.set('hello')
-    expect(s()).toBe('hello')
-  })
-
-  test('peek reads value without tracking', () => {
-    const s = signal(42)
-    let count = 0
-    effect(() => {
-      s.peek() // should NOT track
-      count++
-    })
-    expect(count).toBe(1)
-    s.set(100)
-    expect(count).toBe(1) // no re-run because peek doesn't track
-    expect(s.peek()).toBe(100)
-  })
-
-  test('subscribe adds a static listener', () => {
-    const s = signal(0)
-    let notified = 0
-    const unsub = s.subscribe(() => {
-      notified++
-    })
-
-    s.set(1)
-    expect(notified).toBe(1)
-    s.set(2)
-    expect(notified).toBe(2)
-
-    unsub()
-    s.set(3)
-    expect(notified).toBe(2) // unsubscribed
-  })
-
-  test('subscribe disposer is safe to call multiple times', () => {
-    const s = signal(0)
-    const unsub = s.subscribe(() => {})
-    unsub()
-    unsub() // should not throw
-  })
-
-  test('label getter returns name from options', () => {
-    const s = signal(0, { name: 'counter' })
-    expect(s.label).toBe('counter')
-  })
-
-  test('label setter updates the name', () => {
-    const s = signal(0)
-    expect(s.label).toBeUndefined()
-    s.label = 'renamed'
-    expect(s.label).toBe('renamed')
-  })
-
-  test('debug() returns signal info', () => {
-    const s = signal(42, { name: 'test' })
-    const info = s.debug()
-    expect(info.name).toBe('test')
-    expect(info.value).toBe(42)
-    expect(info.subscriberCount).toBe(0)
-  })
-
-  test('debug() reports subscriber count', () => {
-    const s = signal(0)
-    s.subscribe(() => {})
-    s.subscribe(() => {})
-    const info = s.debug()
-    expect(info.subscriberCount).toBe(2)
-  })
-
-  test('signal without options has undefined name', () => {
-    const s = signal(0)
-    expect(s.label).toBeUndefined()
-    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 is removed from the set after disposal', () => {
-      const s = signal(0)
-      let calls = 0
-      const dispose = s.direct(() => {
-        calls++
-      })
-
-      // Internal `_d` is a Set (not an unbounded array — see signal.ts).
-      const internal = s as unknown as { _d: Set<() => void> | null }
-      expect(internal._d).not.toBeNull()
-      expect(internal._d!.size).toBe(1)
-      s.set(1)
-      expect(calls).toBe(1)
-
-      dispose()
-      // O(1) removal — the slot is GONE, not nulled-and-retained.
-      expect(internal._d!.size).toBe(0)
-      s.set(2)
-      expect(calls).toBe(1) // disposed updater not invoked
-    })
-  })
-
-  describe('signal.direct() for template binding', () => {
-    test('direct updater is called synchronously on signal change', () => {
-      const s = signal(0)
-      const values: number[] = []
-      s.direct(() => {
-        values.push(s.peek())
-      })
-
-      s.set(1)
-      expect(values).toEqual([1])
-      s.set(2)
-      expect(values).toEqual([1, 2])
-    })
-
-    test('direct updaters are batch-aware', () => {
-      const s = signal(0)
-      let calls = 0
-      s.direct(() => {
-        calls++
-      })
-
-      batch(() => {
-        s.set(1)
-        s.set(2)
-        s.set(3)
-      })
-      // Should only be called once after batch (deduplication via Set)
-      expect(calls).toBe(1)
-    })
-
-    test('direct updater set initializes lazily', () => {
-      const s = signal(0)
-      const internal = s as unknown as { _d: Set<() => void> | null }
-      expect(internal._d).toBeNull()
-      s.direct(() => {})
-      expect(internal._d).not.toBeNull()
-      expect(internal._d!.size).toBe(1)
-    })
-
-    test('churned direct bindings do not accumulate (no unbounded growth)', () => {
-      // Regression for the array-form leak: a long-lived signal whose
-      // direct bindings register+dispose repeatedly (e.g. <For> rows
-      // re-mounting) must keep `_d` bounded to the LIVE set, not grow
-      // one permanent dead slot per ever-registered binding.
-      const s = signal(0)
-      const internal = s as unknown as { _d: Set<() => void> | null }
-      for (let i = 0; i < 10_000; i++) {
-        const dispose = s.direct(() => {})
-        dispose()
-      }
-      expect(internal._d!.size).toBe(0)
-      // One live binding survives → notify cost is O(live), not O(10_000).
-      const dispose = s.direct(() => {})
-      expect(internal._d!.size).toBe(1)
-      dispose()
-    })
-  })
-
-  describe('signal misuse warning in dev', () => {
-    test('warns when signal is called with arguments', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const s = signal(42)
-      // Call signal with an argument (common mistake — trying to set via call)
-      ;(s as unknown as (v: number) => number)(99)
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('signal() was called with an argument'),
-      )
-      // Value should not change — the argument is ignored
-      expect(s()).toBe(42)
-      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

@@ -1,286 +0,0 @@
-import { effect } from '../effect'
-import { reconcile } from '../reconcile'
-import { createStore, isStore } from '../store'
-
-describe('createStore', () => {
-  test('reads primitive properties reactively', () => {
-    const state = createStore({ count: 0 })
-    const calls: number[] = []
-    effect(() => {
-      calls.push(state.count)
-    })
-    expect(calls).toEqual([0])
-    state.count = 1
-    expect(calls).toEqual([0, 1])
-    state.count = 1 // no-op (same value)
-    expect(calls).toEqual([0, 1])
-  })
-
-  test('deep reactive — nested object', () => {
-    const state = createStore({ user: { name: 'Alice', age: 30 } })
-    const names: string[] = []
-    effect(() => {
-      names.push(state.user.name)
-    })
-    expect(names).toEqual(['Alice'])
-    state.user.name = 'Bob'
-    expect(names).toEqual(['Alice', 'Bob'])
-  })
-
-  test('deep reactive — nested change does NOT re-run parent-only effects', () => {
-    const state = createStore({ user: { name: 'Alice', age: 30 } })
-    const userCalls: number[] = []
-    const nameCalls: string[] = []
-    effect(() => {
-      userCalls.push(1)
-      void state.user
-    }) // tracks user object
-    effect(() => {
-      nameCalls.push(state.user.name)
-    }) // tracks name only
-    expect(userCalls.length).toBe(1)
-    state.user.age = 31
-    // Only the age signal fires — user object didn't change, name didn't change
-    expect(nameCalls).toEqual(['Alice']) // name effect didn't re-run
-  })
-
-  test('array — tracks length on push', () => {
-    const state = createStore({ items: [1, 2, 3] })
-    const lengths: number[] = []
-    effect(() => {
-      lengths.push(state.items.length)
-    })
-    expect(lengths).toEqual([3])
-    state.items.push(4)
-    expect(lengths).toEqual([3, 4])
-  })
-
-  test('array — tracks index access', () => {
-    const state = createStore({ items: ['a', 'b'] })
-    const values: string[] = []
-    effect(() => {
-      values.push(state.items[0] as string)
-    })
-    expect(values).toEqual(['a'])
-    state.items[0] = 'x'
-    expect(values).toEqual(['a', 'x'])
-    state.items[1] = 'y' // different index — should not re-run this effect
-    expect(values).toEqual(['a', 'x'])
-  })
-
-  test('isStore identifies proxy', () => {
-    const raw = { x: 1 }
-    const store = createStore(raw)
-    expect(isStore(store)).toBe(true)
-    expect(isStore(raw)).toBe(false)
-    expect(isStore(null)).toBe(false)
-    expect(isStore(42)).toBe(false)
-  })
-
-  test('same raw object returns same proxy', () => {
-    const raw = { a: 1 }
-    const s1 = createStore(raw)
-    const s2 = createStore(raw)
-    expect(s1).toBe(s2)
-  })
-
-  test('deep nested object mutations trigger fine-grained updates', () => {
-    const state = createStore({
-      a: { b: { c: { d: 1 } } },
-    })
-    const dValues: number[] = []
-    effect(() => {
-      dValues.push(state.a.b.c.d)
-    })
-    expect(dValues).toEqual([1])
-    state.a.b.c.d = 2
-    expect(dValues).toEqual([1, 2])
-  })
-
-  test('replacing a nested object triggers dependent effects', () => {
-    const state = createStore({ user: { name: 'Alice', address: { city: 'NYC' } } })
-    const cities: string[] = []
-    effect(() => {
-      cities.push(state.user.address.city)
-    })
-    expect(cities).toEqual(['NYC'])
-    // Replace the address object entirely
-    state.user.address = { city: 'LA' }
-    expect(cities).toEqual(['NYC', 'LA'])
-  })
-
-  test('array splice triggers length and index updates', () => {
-    const state = createStore({ items: ['a', 'b', 'c', 'd'] })
-    const lengths: number[] = []
-    effect(() => {
-      lengths.push(state.items.length)
-    })
-    expect(lengths).toEqual([4])
-    state.items.splice(1, 2) // removes "b", "c"
-    expect(lengths).toEqual([4, 2])
-    expect([...state.items]).toEqual(['a', 'd'])
-  })
-
-  test('array pop triggers length update', () => {
-    const state = createStore({ items: [1, 2, 3] })
-    const lengths: number[] = []
-    effect(() => {
-      lengths.push(state.items.length)
-    })
-    expect(lengths).toEqual([3])
-    state.items.pop()
-    expect(lengths).toEqual([3, 2])
-  })
-
-  test('delete property triggers reactivity', () => {
-    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])
-  })
-
-  // 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[] = []
-    effect(() => {
-      lengths.push(state.items.length)
-    })
-    expect(lengths).toEqual([5])
-    state.items.length = 2
-    expect(lengths).toEqual([5, 2])
-  })
-
-  test('symbol property access does not trigger tracking', () => {
-    const sym = Symbol('test')
-    const raw = { x: 1 } as Record<string | symbol, unknown>
-    raw[sym] = 'hidden'
-    const state = createStore(raw)
-    expect(state[sym]).toBe('hidden')
-  })
-
-  test('symbol property set goes through to target', () => {
-    const sym = Symbol('test')
-    const state = createStore({} as Record<string | symbol, unknown>)
-    state[sym] = 'value'
-    expect(state[sym]).toBe('value')
-  })
-
-  test('has trap works with in operator', () => {
-    const state = createStore({ a: 1 })
-    expect('a' in state).toBe(true)
-    expect('b' in state).toBe(false)
-  })
-
-  test('ownKeys returns correct keys', () => {
-    const state = createStore({ a: 1, b: 2 })
-    expect(Object.keys(state)).toEqual(['a', 'b'])
-  })
-})
-
-describe('reconcile', () => {
-  test('updates only changed scalar properties', () => {
-    const state = createStore({ name: 'Alice', age: 30 })
-    const nameCalls: string[] = []
-    const ageCalls: number[] = []
-    effect(() => {
-      nameCalls.push(state.name)
-    })
-    effect(() => {
-      ageCalls.push(state.age)
-    })
-    reconcile({ name: 'Alice', age: 31 }, state)
-    expect(nameCalls).toEqual(['Alice']) // unchanged — no re-run
-    expect(ageCalls).toEqual([30, 31]) // changed — re-ran
-  })
-
-  test('reconciles nested objects recursively', () => {
-    const state = createStore({ user: { name: 'Alice', age: 30 } })
-    const nameCalls: string[] = []
-    effect(() => {
-      nameCalls.push(state.user.name)
-    })
-    reconcile({ user: { name: 'Bob', age: 30 } }, state)
-    expect(nameCalls).toEqual(['Alice', 'Bob'])
-  })
-
-  test('reconciles arrays by index', () => {
-    const state = createStore({ items: ['a', 'b', 'c'] })
-    const calls: string[][] = []
-    effect(() => {
-      calls.push([...state.items])
-    })
-    reconcile({ items: ['a', 'X', 'c'] }, state)
-    expect(state.items[1]).toBe('X')
-    expect(calls.length).toBe(2) // initial + after reconcile
-  })
-
-  test('trims excess array elements', () => {
-    const state = createStore({ items: [1, 2, 3, 4, 5] })
-    reconcile({ items: [1, 2] }, state)
-    expect(state.items.length).toBe(2)
-  })
-
-  test('removes deleted keys', () => {
-    const state = createStore({ a: 1, b: 2, c: 3 } as Record<string, number>)
-    reconcile({ a: 1, b: 2 }, state)
-    expect('c' in state).toBe(false)
-  })
-})