@pyreon/reactivity 0.11.4 → 0.11.6

package/src/tests/cell.test.ts

@@ -1,18 +1,18 @@
-import { Cell, cell } from "../cell"
+import { Cell, cell } from '../cell'
 
-describe("Cell", () => {
-  test("stores and reads initial value", () => {
+describe('Cell', () => {
+  test('stores and reads initial value', () => {
     const c = cell(42)
     expect(c.peek()).toBe(42)
   })
 
-  test("set() updates value", () => {
-    const c = cell("hello")
-    c.set("world")
-    expect(c.peek()).toBe("world")
+  test('set() updates value', () => {
+    const c = cell('hello')
+    c.set('world')
+    expect(c.peek()).toBe('world')
   })
 
-  test("set() skips when value is the same (Object.is)", () => {
+  test('set() skips when value is the same (Object.is)', () => {
     const c = cell(1)
     let calls = 0
     c.listen(() => calls++)
@@ -20,23 +20,23 @@ describe("Cell", () => {
     expect(calls).toBe(0)
   })
 
-  test("update() applies function to current value", () => {
+  test('update() applies function to current value', () => {
     const c = cell(10)
     c.update((v) => v + 5)
     expect(c.peek()).toBe(15)
   })
 
-  test("listen() fires on set()", () => {
-    const c = cell("a")
+  test('listen() fires on set()', () => {
+    const c = cell('a')
     let fired = false
     c.listen(() => {
       fired = true
     })
-    c.set("b")
+    c.set('b')
     expect(fired).toBe(true)
   })
 
-  test("listen() single-listener fast path (no Set allocated)", () => {
+  test('listen() single-listener fast path (no Set allocated)', () => {
     const c = cell(0)
     let count = 0
     c.listen(() => count++)
@@ -47,7 +47,7 @@ describe("Cell", () => {
     expect(count).toBe(1)
   })
 
-  test("listen() promotes to Set with multiple listeners", () => {
+  test('listen() promotes to Set with multiple listeners', () => {
     const c = cell(0)
     let a = 0
     let b = 0
@@ -60,7 +60,7 @@ describe("Cell", () => {
     expect(b).toBe(1)
   })
 
-  test("subscribe() returns working unsubscribe (single listener)", () => {
+  test('subscribe() returns working unsubscribe (single listener)', () => {
     const c = cell(0)
     let count = 0
     const unsub = c.subscribe(() => count++)
@@ -71,7 +71,7 @@ describe("Cell", () => {
     expect(count).toBe(1) // no more notifications
   })
 
-  test("subscribe() returns working unsubscribe (multi listener)", () => {
+  test('subscribe() returns working unsubscribe (multi listener)', () => {
     const c = cell(0)
     let a = 0
     let b = 0
@@ -86,12 +86,12 @@ describe("Cell", () => {
     expect(b).toBe(1) // unsubscribed
   })
 
-  test("cell() factory returns Cell instance", () => {
-    const c = cell("x")
+  test('cell() factory returns Cell instance', () => {
+    const c = cell('x')
     expect(c).toBeInstanceOf(Cell)
   })
 
-  test("multiple rapid updates notify correctly", () => {
+  test('multiple rapid updates notify correctly', () => {
     const c = cell(0)
     const values: number[] = []
     c.listen(() => values.push(c.peek()))
@@ -101,7 +101,7 @@ describe("Cell", () => {
     expect(values).toEqual([1, 2, 3])
   })
 
-  test("NaN equality (Object.is)", () => {
+  test('NaN equality (Object.is)', () => {
     const c = cell(Number.NaN)
     let calls = 0
     c.listen(() => calls++)
@@ -109,7 +109,7 @@ describe("Cell", () => {
     expect(calls).toBe(0) // Object.is(NaN, NaN) is true
   })
 
-  test("subscribe() unsubscribe works after promotion to Set (regression)", () => {
+  test('subscribe() unsubscribe works after promotion to Set (regression)', () => {
     // Bug: first subscriber's disposer became stale after second subscriber
     // promoted _l → _s. The disposer checked _l which was now null.
     const c = cell(0)
@@ -135,7 +135,7 @@ describe("Cell", () => {
     expect(count2).toBe(2)
   })
 
-  test("subscribe() unsubscribe order: second before first", () => {
+  test('subscribe() unsubscribe order: second before first', () => {
     const c = cell(0)
     let count1 = 0
     let count2 = 0

package/src/tests/computed.test.ts

@@ -1,15 +1,15 @@
-import { computed } from "../computed"
-import { effect } from "../effect"
-import { signal } from "../signal"
+import { computed } from '../computed'
+import { effect } from '../effect'
+import { signal } from '../signal'
 
-describe("computed", () => {
-  test("computes derived value", () => {
+describe('computed', () => {
+  test('computes derived value', () => {
     const s = signal(2)
     const doubled = computed(() => s() * 2)
     expect(doubled()).toBe(4)
   })
 
-  test("updates when dependency changes", () => {
+  test('updates when dependency changes', () => {
     const s = signal(3)
     const tripled = computed(() => s() * 3)
     expect(tripled()).toBe(9)
@@ -17,7 +17,7 @@ describe("computed", () => {
     expect(tripled()).toBe(12)
   })
 
-  test("is lazy — does not compute until read", () => {
+  test('is lazy — does not compute until read', () => {
     let computations = 0
     const s = signal(0)
     const c = computed(() => {
@@ -29,7 +29,7 @@ describe("computed", () => {
     expect(computations).toBe(1)
   })
 
-  test("is memoized — does not recompute on repeated reads", () => {
+  test('is memoized — does not recompute on repeated reads', () => {
     let computations = 0
     const s = signal(5)
     const c = computed(() => {
@@ -42,7 +42,7 @@ describe("computed", () => {
     expect(computations).toBe(1)
   })
 
-  test("recomputes only when dirty", () => {
+  test('recomputes only when dirty', () => {
     let computations = 0
     const s = signal(1)
     const c = computed(() => {
@@ -58,7 +58,7 @@ describe("computed", () => {
     expect(computations).toBe(2) // still memoized
   })
 
-  test("chains correctly", () => {
+  test('chains correctly', () => {
     const base = signal(2)
     const doubled = computed(() => base() * 2)
     const quadrupled = computed(() => doubled() * 2)
@@ -67,7 +67,7 @@ describe("computed", () => {
     expect(quadrupled()).toBe(12)
   })
 
-  test("dispose stops recomputation", () => {
+  test('dispose stops recomputation', () => {
     const s = signal(1)
     let computations = 0
     const c = computed(() => {
@@ -82,7 +82,7 @@ describe("computed", () => {
     // (the computed is no longer subscribed to s)
   })
 
-  test("custom equals skips downstream notification when equal", () => {
+  test('custom equals skips downstream notification when equal', () => {
     const s = signal(3)
     let downstream = 0
 
@@ -106,7 +106,7 @@ describe("computed", () => {
     expect(c()).toBe(1)
   })
 
-  test("custom equals with array comparison", () => {
+  test('custom equals with array comparison', () => {
     const items = signal([1, 2, 3])
     let downstream = 0
 
@@ -130,7 +130,7 @@ describe("computed", () => {
     expect(downstream).toBe(2)
   })
 
-  test("computed used as dependency inside an effect (subscribe path)", () => {
+  test('computed used as dependency inside an effect (subscribe path)', () => {
     const s = signal(10)
     const c = computed(() => s() + 1)
     let result = 0
@@ -144,7 +144,7 @@ describe("computed", () => {
     expect(result).toBe(21)
   })
 
-  test("._v returns cached value", () => {
+  test('._v returns cached value', () => {
     const s = signal(5)
     const doubled = computed(() => s() * 2)
     // First access triggers computation
@@ -154,7 +154,7 @@ describe("computed", () => {
     expect(doubled._v).toBe(14)
   })
 
-  test(".direct() fires updater on recompute", () => {
+  test('.direct() fires updater on recompute', () => {
     const s = signal(1)
     const doubled = computed(() => s() * 2)
     doubled() // initialize
@@ -176,7 +176,7 @@ describe("computed", () => {
     expect(called).toBe(2) // disposed, no more calls
   })
 
-  test(".direct() works with equals option", () => {
+  test('.direct() works with equals option', () => {
     const s = signal(1)
     const clamped = computed(() => Math.min(s(), 10), {
       equals: (a, b) => a === b,
@@ -198,8 +198,8 @@ describe("computed", () => {
     expect(called).toBe(2) // equals suppresses
   })
 
-  describe("_v with equals after disposal", () => {
-    test("_v returns last cached value after dispose()", () => {
+  describe('_v with equals after disposal', () => {
+    test('_v returns last cached value after dispose()', () => {
       const s = signal(5)
       const doubled = computed(() => s() * 2)
       expect(doubled._v).toBe(10) // triggers initial computation
@@ -215,7 +215,7 @@ describe("computed", () => {
       expect(doubled._v).toBe(14)
     })
 
-    test("computed with equals: _v only updates when equality check fails", () => {
+    test('computed with equals: _v only updates when equality check fails', () => {
       const s = signal(3)
       const floored = computed(() => Math.floor(s() / 10), {
         equals: (a, b) => a === b,
@@ -233,7 +233,7 @@ describe("computed", () => {
       expect(floored._v).toBe(1)
     })
 
-    test("multiple .direct() updaters on computed, dispose one", () => {
+    test('multiple .direct() updaters on computed, dispose one', () => {
       const s = signal(1)
       const doubled = computed(() => s() * 2)
       doubled() // initialize
@@ -267,8 +267,8 @@ describe("computed", () => {
     })
   })
 
-  describe("diamond pattern cleanup", () => {
-    test("a -> b, c -> d diamond: d only recomputes once per a change", () => {
+  describe('diamond pattern cleanup', () => {
+    test('a -> b, c -> d diamond: d only recomputes once per a change', () => {
       const a = signal(1)
       const b = computed(() => a() + 1)
       const c = computed(() => a() + 2)
@@ -288,7 +288,7 @@ describe("computed", () => {
       expect(dComputations).toBe(2)
     })
 
-    test("dispose middle node in diamond, verify no stale subscriptions", () => {
+    test('dispose middle node in diamond, verify no stale subscriptions', () => {
       const a = signal(1)
       const b = computed(() => a() * 2)
       const c = computed(() => a() * 3)

package/src/tests/createSelector.test.ts

@@ -1,9 +1,9 @@
-import { createSelector } from "../createSelector"
-import { effect } from "../effect"
-import { signal } from "../signal"
+import { createSelector } from '../createSelector'
+import { effect } from '../effect'
+import { signal } from '../signal'
 
-describe("createSelector", () => {
-  test("returns true for the currently selected value", () => {
+describe('createSelector', () => {
+  test('returns true for the currently selected value', () => {
     const selected = signal(1)
     const isSelected = createSelector(() => selected())
 
@@ -14,7 +14,7 @@ describe("createSelector", () => {
     expect(result).toBe(true)
   })
 
-  test("returns false for non-selected values", () => {
+  test('returns false for non-selected values', () => {
     const selected = signal(1)
     const isSelected = createSelector(() => selected())
 
@@ -25,7 +25,7 @@ describe("createSelector", () => {
     expect(result).toBe(false)
   })
 
-  test("only notifies affected subscribers when selection changes", () => {
+  test('only notifies affected subscribers when selection changes', () => {
     const selected = signal(1)
     const isSelected = createSelector(() => selected())
 
@@ -57,7 +57,7 @@ describe("createSelector", () => {
     expect(runs3).toBe(1) // unaffected
   })
 
-  test("does not notify when source changes to the same value", () => {
+  test('does not notify when source changes to the same value', () => {
     const selected = signal(1)
     const isSelected = createSelector(() => selected())
 
@@ -71,7 +71,7 @@ describe("createSelector", () => {
     expect(runs).toBe(1)
   })
 
-  test("works when changing to a value with no subscribers", () => {
+  test('works when changing to a value with no subscribers', () => {
     const selected = signal(1)
     const isSelected = createSelector(() => selected())
 
@@ -86,7 +86,7 @@ describe("createSelector", () => {
     expect(runs).toBe(2) // old bucket (1) notified
   })
 
-  test("reuses host objects for the same value", () => {
+  test('reuses host objects for the same value', () => {
     const selected = signal(1)
     const isSelected = createSelector(() => selected())
 
@@ -108,7 +108,7 @@ describe("createSelector", () => {
     expect(result2).toBe(false)
   })
 
-  test("tracks correctly outside an effect (no activeEffect)", () => {
+  test('tracks correctly outside an effect (no activeEffect)', () => {
     const selected = signal(1)
     const isSelected = createSelector(() => selected())
 
@@ -117,8 +117,8 @@ describe("createSelector", () => {
     expect(isSelected(2)).toBe(false)
   })
 
-  describe("large subscriber sets", () => {
-    test("many subscribers (20+), only affected buckets notified", () => {
+  describe('large subscriber sets', () => {
+    test('many subscribers (20+), only affected buckets notified', () => {
       const selected = signal(0)
       const isSelected = createSelector(() => selected())
 
@@ -151,8 +151,8 @@ describe("createSelector", () => {
       expect(unaffectedAfterSecond).toBe(true)
     })
 
-    test("selector with undefined and null values", () => {
-      const selected = signal<string | null | undefined>("a")
+    test('selector with undefined and null values', () => {
+      const selected = signal<string | null | undefined>('a')
       const isSelected = createSelector(() => selected())
 
       let nullRuns = 0
@@ -168,7 +168,7 @@ describe("createSelector", () => {
         undefRuns++
       })
       effect(() => {
-        isSelected("a")
+        isSelected('a')
         aRuns++
       })
 
@@ -189,7 +189,7 @@ describe("createSelector", () => {
       expect(aRuns).toBe(2) // unaffected
     })
 
-    test("rapid selector changes", () => {
+    test('rapid selector changes', () => {
       const selected = signal(0)
       const isSelected = createSelector(() => selected())
 

package/src/tests/debug.test.ts

@@ -1,35 +1,35 @@
-import { _notifyTraceListeners, inspectSignal, isTracing, onSignalUpdate, why } from "../debug"
-import { signal } from "../signal"
+import { _notifyTraceListeners, inspectSignal, isTracing, onSignalUpdate, why } from '../debug'
+import { signal } from '../signal'
 
-describe("debug", () => {
-  describe("onSignalUpdate / isTracing", () => {
-    test("isTracing is false by default", () => {
+describe('debug', () => {
+  describe('onSignalUpdate / isTracing', () => {
+    test('isTracing is false by default', () => {
       expect(isTracing()).toBe(false)
     })
 
-    test("registering a listener enables tracing", () => {
+    test('registering a listener enables tracing', () => {
       const dispose = onSignalUpdate(() => {})
       expect(isTracing()).toBe(true)
       dispose()
       expect(isTracing()).toBe(false)
     })
 
-    test("listener receives signal update events", () => {
+    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" })
+      const s = signal(1, { name: 'count' })
       s.set(2)
 
       expect(events.length).toBe(1)
-      expect(events[0]).toEqual({ name: "count", prev: 1, next: 2 })
+      expect(events[0]).toEqual({ name: 'count', prev: 1, next: 2 })
 
       dispose()
     })
 
-    test("dispose removes only the specific listener", () => {
+    test('dispose removes only the specific listener', () => {
       let calls1 = 0
       let calls2 = 0
       const dispose1 = onSignalUpdate(() => calls1++)
@@ -50,20 +50,20 @@ describe("debug", () => {
       expect(isTracing()).toBe(false)
     })
 
-    test("dispose is safe to call when listeners already null", () => {
+    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", () => {
+    test('_notifyTraceListeners does nothing when no listeners', () => {
       const s = signal(0)
       // Should not throw
       _notifyTraceListeners(s, 0, 1)
     })
 
-    test("event includes stack and timestamp", () => {
+    test('event includes stack and timestamp', () => {
       let event: { stack: string; timestamp: number } | undefined
       const dispose = onSignalUpdate((e) => {
         event = { stack: e.stack, timestamp: e.timestamp }
@@ -73,20 +73,20 @@ describe("debug", () => {
       s.set(1)
 
       expect(event).toBeDefined()
-      expect(typeof event?.stack).toBe("string")
-      expect(typeof event?.timestamp).toBe("number")
+      expect(typeof event?.stack).toBe('string')
+      expect(typeof event?.timestamp).toBe('number')
 
       dispose()
     })
   })
 
-  describe("why", () => {
-    test("logs signal updates to console", async () => {
+  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" })
+      const s = signal(1, { name: 'test' })
       why()
       s.set(2)
 
@@ -109,21 +109,21 @@ describe("debug", () => {
 
       const noUpdateLog =
         logs.find((args) =>
-          typeof args[0] === "string" ? args[0].includes("No signal") : false,
+          typeof args[0] === 'string' ? args[0].includes('No signal') : false,
         ) ||
-        logs.find((args) => (typeof args[1] === "string" ? args[1].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 () => {
+    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" })
+      const s = signal(0, { name: 'x' })
       s.set(1)
 
       await new Promise((r) => queueMicrotask(() => r(undefined)))
@@ -131,7 +131,7 @@ describe("debug", () => {
       console.log = origLog
     })
 
-    test("logs anonymous signal name when no name is set", async () => {
+    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)
@@ -143,15 +143,15 @@ describe("debug", () => {
       await new Promise((r) => queueMicrotask(() => r(undefined)))
 
       const anonLog = logs.find((args) =>
-        args.some((a) => typeof a === "string" && a.includes("anonymous")),
+        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", () => {
+  describe('inspectSignal', () => {
+    test('prints signal info and returns debug info', () => {
       const groupCalls: unknown[][] = []
       const logCalls: unknown[][] = []
       const origGroup = console.group
@@ -161,10 +161,10 @@ describe("debug", () => {
       console.log = (...args: unknown[]) => logCalls.push(args)
       console.groupEnd = () => {}
 
-      const s = signal(42, { name: "count" })
+      const s = signal(42, { name: 'count' })
       const info = inspectSignal(s)
 
-      expect(info.name).toBe("count")
+      expect(info.name).toBe('count')
       expect(info.value).toBe(42)
       expect(info.subscriberCount).toBe(0)
       expect(groupCalls.length).toBe(1)
@@ -175,7 +175,7 @@ describe("debug", () => {
       console.groupEnd = origEnd
     })
 
-    test("handles anonymous signal", () => {
+    test('handles anonymous signal', () => {
       const origGroup = console.group
       const origLog = console.log
       const origEnd = console.groupEnd