@pyreon/reactivity 0.11.4 → 0.11.6

package/src/tests/scope.test.ts

@@ -1,18 +1,18 @@
-import { effect } from "../effect"
-import { EffectScope, effectScope, getCurrentScope, setCurrentScope } from "../scope"
-import { signal } from "../signal"
+import { effect } from '../effect'
+import { EffectScope, effectScope, getCurrentScope, setCurrentScope } from '../scope'
+import { signal } from '../signal'
 
-describe("effectScope", () => {
-  test("creates an EffectScope instance", () => {
+describe('effectScope', () => {
+  test('creates an EffectScope instance', () => {
     const scope = effectScope()
     expect(scope).toBeInstanceOf(EffectScope)
   })
 
-  test("getCurrentScope returns null by default", () => {
+  test('getCurrentScope returns null by default', () => {
     expect(getCurrentScope()).toBeNull()
   })
 
-  test("setCurrentScope sets and clears the current scope", () => {
+  test('setCurrentScope sets and clears the current scope', () => {
     const scope = effectScope()
     setCurrentScope(scope)
     expect(getCurrentScope()).toBe(scope)
@@ -20,7 +20,7 @@ describe("effectScope", () => {
     expect(getCurrentScope()).toBeNull()
   })
 
-  test("effects created within a scope are disposed on stop", () => {
+  test('effects created within a scope are disposed on stop', () => {
     const scope = effectScope()
     setCurrentScope(scope)
 
@@ -42,7 +42,7 @@ describe("effectScope", () => {
     expect(count).toBe(2) // effect disposed, no re-run
   })
 
-  test("stop is idempotent — second call does nothing", () => {
+  test('stop is idempotent — second call does nothing', () => {
     const scope = effectScope()
     setCurrentScope(scope)
 
@@ -60,14 +60,14 @@ describe("effectScope", () => {
     expect(count).toBe(1)
   })
 
-  test("add is ignored after scope is stopped", () => {
+  test('add is ignored after scope is stopped', () => {
     const scope = effectScope()
     scope.stop()
     // Should not throw — add is silently ignored
     scope.add({ dispose() {} })
   })
 
-  test("runInScope temporarily re-activates the scope", () => {
+  test('runInScope temporarily re-activates the scope', () => {
     const scope = effectScope()
     setCurrentScope(null)
 
@@ -91,7 +91,7 @@ describe("effectScope", () => {
     expect(count).toBe(2) // disposed via scope
   })
 
-  test("runInScope restores previous scope even on error", () => {
+  test('runInScope restores previous scope even on error', () => {
     const scope = effectScope()
     const prevScope = effectScope()
     setCurrentScope(prevScope)
@@ -99,7 +99,7 @@ describe("effectScope", () => {
     try {
       scope.runInScope(() => {
         expect(getCurrentScope()).toBe(scope)
-        throw new Error("test")
+        throw new Error('test')
       })
     } catch {
       // expected
@@ -115,7 +115,7 @@ describe("effectScope", () => {
     expect(result).toBe(42)
   })
 
-  test("addUpdateHook + notifyEffectRan fires hooks via microtask", async () => {
+  test('addUpdateHook + notifyEffectRan fires hooks via microtask', async () => {
     const scope = effectScope()
     let hookCalled = 0
 
@@ -130,14 +130,14 @@ describe("effectScope", () => {
     expect(hookCalled).toBe(1)
   })
 
-  test("notifyEffectRan does nothing when no update hooks", async () => {
+  test('notifyEffectRan does nothing when no update hooks', async () => {
     const scope = effectScope()
     // Should not throw — early return when _updateHooks is empty
     scope.notifyEffectRan()
     await new Promise((r) => setTimeout(r, 10))
   })
 
-  test("notifyEffectRan does nothing after scope is stopped", async () => {
+  test('notifyEffectRan does nothing after scope is stopped', async () => {
     const scope = effectScope()
     let hookCalled = 0
 
@@ -152,7 +152,7 @@ describe("effectScope", () => {
     expect(hookCalled).toBe(0)
   })
 
-  test("notifyEffectRan deduplicates — only one microtask while pending", async () => {
+  test('notifyEffectRan deduplicates — only one microtask while pending', async () => {
     const scope = effectScope()
     let hookCalled = 0
 
@@ -168,7 +168,7 @@ describe("effectScope", () => {
     expect(hookCalled).toBe(1) // only fired once
   })
 
-  test("notifyEffectRan skips hooks if scope stopped before microtask fires", async () => {
+  test('notifyEffectRan skips hooks if scope stopped before microtask fires', async () => {
     const scope = effectScope()
     let hookCalled = 0
 
@@ -183,14 +183,14 @@ describe("effectScope", () => {
     expect(hookCalled).toBe(0)
   })
 
-  test("onUpdate hook errors are caught and logged", async () => {
+  test('onUpdate hook errors are caught and logged', async () => {
     const scope = effectScope()
     const errors: unknown[] = []
     const origError = console.error
     console.error = (...args: unknown[]) => errors.push(args)
 
     scope.addUpdateHook(() => {
-      throw new Error("hook error")
+      throw new Error('hook error')
     })
 
     scope.notifyEffectRan()

package/src/tests/signal.test.ts

@@ -1,26 +1,26 @@
-import { batch } from "../batch"
-import { effect } from "../effect"
-import { signal } from "../signal"
+import { batch } from '../batch'
+import { effect } from '../effect'
+import { signal } from '../signal'
 
-describe("signal", () => {
-  test("reads initial value", () => {
+describe('signal', () => {
+  test('reads initial value', () => {
     const s = signal(42)
     expect(s()).toBe(42)
   })
 
-  test("set updates value", () => {
+  test('set updates value', () => {
     const s = signal(0)
     s.set(10)
     expect(s()).toBe(10)
   })
 
-  test("update transforms value", () => {
+  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", () => {
+  test('set with same value does not notify', () => {
     const s = signal(1)
     let calls = 0
     effect(() => {
@@ -34,20 +34,20 @@ describe("signal", () => {
     expect(calls).toBe(2)
   })
 
-  test("works with objects", () => {
+  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", () => {
+  test('works with null and undefined', () => {
     const s = signal<string | null>(null)
     expect(s()).toBeNull()
-    s.set("hello")
-    expect(s()).toBe("hello")
+    s.set('hello')
+    expect(s()).toBe('hello')
   })
 
-  test("peek reads value without tracking", () => {
+  test('peek reads value without tracking', () => {
     const s = signal(42)
     let count = 0
     effect(() => {
@@ -60,7 +60,7 @@ describe("signal", () => {
     expect(s.peek()).toBe(100)
   })
 
-  test("subscribe adds a static listener", () => {
+  test('subscribe adds a static listener', () => {
     const s = signal(0)
     let notified = 0
     const unsub = s.subscribe(() => {
@@ -77,34 +77,34 @@ describe("signal", () => {
     expect(notified).toBe(2) // unsubscribed
   })
 
-  test("subscribe disposer is safe to call multiple times", () => {
+  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 getter returns name from options', () => {
+    const s = signal(0, { name: 'counter' })
+    expect(s.label).toBe('counter')
   })
 
-  test("label setter updates the name", () => {
+  test('label setter updates the name', () => {
     const s = signal(0)
     expect(s.label).toBeUndefined()
-    s.label = "renamed"
-    expect(s.label).toBe("renamed")
+    s.label = 'renamed'
+    expect(s.label).toBe('renamed')
   })
 
-  test("debug() returns signal info", () => {
-    const s = signal(42, { name: "test" })
+  test('debug() returns signal info', () => {
+    const s = signal(42, { name: 'test' })
     const info = s.debug()
-    expect(info.name).toBe("test")
+    expect(info.name).toBe('test')
     expect(info.value).toBe(42)
     expect(info.subscriberCount).toBe(0)
   })
 
-  test("debug() reports subscriber count", () => {
+  test('debug() reports subscriber count', () => {
     const s = signal(0)
     s.subscribe(() => {})
     s.subscribe(() => {})
@@ -112,15 +112,15 @@ describe("signal", () => {
     expect(info.subscriberCount).toBe(2)
   })
 
-  test("signal without options has undefined name", () => {
+  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", () => {
+  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(() => {
@@ -135,7 +135,7 @@ describe("signal", () => {
       expect(called).toBe(1) // not called after disposal
     })
 
-    test("multiple direct updaters, dispose one, others still fire", () => {
+    test('multiple direct updaters, dispose one, others still fire', () => {
       const s = signal(0)
       let calls1 = 0
       let calls2 = 0
@@ -163,22 +163,22 @@ describe("signal", () => {
       expect(calls3).toBe(2) // still active
     })
 
-    test("direct updater slot is null after disposal", () => {
+    test('direct updater slot is null after disposal', () => {
       const s = signal(0)
       const dispose = s.direct(() => {})
 
       // Access internal _d array via cast
       const internal = s as unknown as { _d: ((() => void) | null)[] | null }
       expect(internal._d).not.toBeNull()
-      expect(internal._d![0]).toBeTypeOf("function")
+      expect(internal._d![0]).toBeTypeOf('function')
 
       dispose()
       expect(internal._d![0]).toBeNull()
     })
   })
 
-  describe("signal.direct() for template binding", () => {
-    test("direct updater is called synchronously on signal change", () => {
+  describe('signal.direct() for template binding', () => {
+    test('direct updater is called synchronously on signal change', () => {
       const s = signal(0)
       const values: number[] = []
       s.direct(() => {
@@ -191,7 +191,7 @@ describe("signal", () => {
       expect(values).toEqual([1, 2])
     })
 
-    test("direct updaters are batch-aware", () => {
+    test('direct updaters are batch-aware', () => {
       const s = signal(0)
       let calls = 0
       s.direct(() => {
@@ -207,7 +207,7 @@ describe("signal", () => {
       expect(calls).toBe(1)
     })
 
-    test("direct updater with no prior direct array initializes lazily", () => {
+    test('direct updater with no prior direct array initializes lazily', () => {
       const s = signal(0)
       const internal = s as unknown as { _d: ((() => void) | null)[] | null }
       expect(internal._d).toBeNull()
@@ -217,14 +217,14 @@ describe("signal", () => {
     })
   })
 
-  describe("signal misuse warning in dev", () => {
-    test("warns when signal is called with arguments", () => {
-      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  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"),
+        expect.stringContaining('signal() was called with an argument'),
       )
       // Value should not change — the argument is ignored
       expect(s()).toBe(42)

package/src/tests/store.test.ts

@@ -1,9 +1,9 @@
-import { effect } from "../effect"
-import { reconcile } from "../reconcile"
-import { createStore, isStore } from "../store"
+import { effect } from '../effect'
+import { reconcile } from '../reconcile'
+import { createStore, isStore } from '../store'
 
-describe("createStore", () => {
-  test("reads primitive properties reactively", () => {
+describe('createStore', () => {
+  test('reads primitive properties reactively', () => {
     const state = createStore({ count: 0 })
     const calls: number[] = []
     effect(() => {
@@ -16,19 +16,19 @@ describe("createStore", () => {
     expect(calls).toEqual([0, 1])
   })
 
-  test("deep reactive — nested object", () => {
-    const state = createStore({ user: { name: "Alice", age: 30 } })
+  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"])
+    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 } })
+  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(() => {
@@ -41,10 +41,10 @@ describe("createStore", () => {
     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
+    expect(nameCalls).toEqual(['Alice']) // name effect didn't re-run
   })
 
-  test("array — tracks length on push", () => {
+  test('array — tracks length on push', () => {
     const state = createStore({ items: [1, 2, 3] })
     const lengths: number[] = []
     effect(() => {
@@ -55,20 +55,20 @@ describe("createStore", () => {
     expect(lengths).toEqual([3, 4])
   })
 
-  test("array — tracks index access", () => {
-    const state = createStore({ items: ["a", "b"] })
+  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"])
+    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", () => {
+  test('isStore identifies proxy', () => {
     const raw = { x: 1 }
     const store = createStore(raw)
     expect(isStore(store)).toBe(true)
@@ -77,14 +77,14 @@ describe("createStore", () => {
     expect(isStore(42)).toBe(false)
   })
 
-  test("same raw object returns same proxy", () => {
+  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", () => {
+  test('deep nested object mutations trigger fine-grained updates', () => {
     const state = createStore({
       a: { b: { c: { d: 1 } } },
     })
@@ -97,20 +97,20 @@ describe("createStore", () => {
     expect(dValues).toEqual([1, 2])
   })
 
-  test("replacing a nested object triggers dependent effects", () => {
-    const state = createStore({ user: { name: "Alice", address: { city: "NYC" } } })
+  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"])
+    expect(cities).toEqual(['NYC'])
     // Replace the address object entirely
-    state.user.address = { city: "LA" }
-    expect(cities).toEqual(["NYC", "LA"])
+    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"] })
+  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)
@@ -118,10 +118,10 @@ describe("createStore", () => {
     expect(lengths).toEqual([4])
     state.items.splice(1, 2) // removes "b", "c"
     expect(lengths).toEqual([4, 2])
-    expect([...state.items]).toEqual(["a", "d"])
+    expect([...state.items]).toEqual(['a', 'd'])
   })
 
-  test("array pop triggers length update", () => {
+  test('array pop triggers length update', () => {
     const state = createStore({ items: [1, 2, 3] })
     const lengths: number[] = []
     effect(() => {
@@ -132,7 +132,7 @@ describe("createStore", () => {
     expect(lengths).toEqual([3, 2])
   })
 
-  test("delete property triggers reactivity", () => {
+  test('delete property triggers reactivity', () => {
     const state = createStore({ a: 1, b: 2 } as Record<string, number | undefined>)
     const bValues: (number | undefined)[] = []
     effect(() => {
@@ -143,7 +143,7 @@ describe("createStore", () => {
     expect(bValues).toEqual([2, undefined])
   })
 
-  test("setting array length directly triggers reactivity", () => {
+  test('setting array length directly triggers reactivity', () => {
     const state = createStore({ items: [1, 2, 3, 4, 5] })
     const lengths: number[] = []
     effect(() => {
@@ -154,36 +154,36 @@ describe("createStore", () => {
     expect(lengths).toEqual([5, 2])
   })
 
-  test("symbol property access does not trigger tracking", () => {
-    const sym = Symbol("test")
+  test('symbol property access does not trigger tracking', () => {
+    const sym = Symbol('test')
     const raw = { x: 1 } as Record<string | symbol, unknown>
-    raw[sym] = "hidden"
+    raw[sym] = 'hidden'
     const state = createStore(raw)
-    expect(state[sym]).toBe("hidden")
+    expect(state[sym]).toBe('hidden')
   })
 
-  test("symbol property set goes through to target", () => {
-    const sym = Symbol("test")
+  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")
+    state[sym] = 'value'
+    expect(state[sym]).toBe('value')
   })
 
-  test("has trap works with in operator", () => {
+  test('has trap works with in operator', () => {
     const state = createStore({ a: 1 })
-    expect("a" in state).toBe(true)
-    expect("b" in state).toBe(false)
+    expect('a' in state).toBe(true)
+    expect('b' in state).toBe(false)
   })
 
-  test("ownKeys returns correct keys", () => {
+  test('ownKeys returns correct keys', () => {
     const state = createStore({ a: 1, b: 2 })
-    expect(Object.keys(state)).toEqual(["a", "b"])
+    expect(Object.keys(state)).toEqual(['a', 'b'])
   })
 })
 
-describe("reconcile", () => {
-  test("updates only changed scalar properties", () => {
-    const state = createStore({ name: "Alice", age: 30 })
+describe('reconcile', () => {
+  test('updates only changed scalar properties', () => {
+    const state = createStore({ name: 'Alice', age: 30 })
     const nameCalls: string[] = []
     const ageCalls: number[] = []
     effect(() => {
@@ -192,41 +192,41 @@ describe("reconcile", () => {
     effect(() => {
       ageCalls.push(state.age)
     })
-    reconcile({ name: "Alice", age: 31 }, state)
-    expect(nameCalls).toEqual(["Alice"]) // unchanged — no re-run
+    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 } })
+  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"])
+    reconcile({ user: { name: 'Bob', age: 30 } }, state)
+    expect(nameCalls).toEqual(['Alice', 'Bob'])
   })
 
-  test("reconciles arrays by index", () => {
-    const state = createStore({ items: ["a", "b", "c"] })
+  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")
+    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", () => {
+  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", () => {
+  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)
+    expect('c' in state).toBe(false)
   })
 })