@pyreon/reactivity 0.11.5 → 0.11.6

package/src/signal.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
 declare const process: { env: { NODE_ENV?: string } } | undefined
 
-const __DEV__ = typeof process !== "undefined" && process?.env?.NODE_ENV !== "production"
+const __DEV__ = typeof process !== 'undefined' && process?.env?.NODE_ENV !== 'production'
 
-import { enqueuePendingNotification, isBatching } from "./batch"
-import { _notifyTraceListeners, isTracing } from "./debug"
-import { notifySubscribers, trackSubscriber } from "./tracking"
+import { enqueuePendingNotification, isBatching } from './batch'
+import { _notifyTraceListeners, isTracing } from './debug'
+import { notifySubscribers, trackSubscriber } from './tracking'
 
 export interface SignalDebugInfo<T> {
   /** Signal name (set via options or inferred) */
@@ -153,9 +153,9 @@ export function signal<T>(initialValue: T, options?: SignalOptions): Signal<T> {
     if (__DEV__ && args.length > 0) {
       // biome-ignore lint/suspicious/noConsole: dev-only signal misuse warning
       console.warn(
-        "[Pyreon] signal() was called with an argument. " +
-          "Use signal.set(value) or signal.update(fn) to write. " +
-          "signal(value) only reads — the argument is ignored.",
+        '[Pyreon] signal() was called with an argument. ' +
+          'Use signal.set(value) or signal.update(fn) to write. ' +
+          'signal(value) only reads — the argument is ignored.',
       )
     }
     trackSubscriber(read as SignalFn<T>)

package/src/store.ts

@@ -13,18 +13,18 @@
  * state.items[0].text = "world"           // only text-tracking effects re-run
  */
 
-import { type Signal, signal } from "./signal"
+import { type Signal, signal } from './signal'
 
 // WeakMap: raw object → its reactive proxy (ensures each raw object gets one proxy)
 const proxyCache = new WeakMap<object, object>()
 
-const IS_STORE = Symbol("pyreon.store")
+const IS_STORE = Symbol('pyreon.store')
 
 /** Returns true if the value is a createStore proxy. */
 export function isStore(value: unknown): boolean {
   return (
     value !== null &&
-    typeof value === "object" &&
+    typeof value === 'object' &&
     (value as Record<symbol, unknown>)[IS_STORE] === true
   )
 }
@@ -58,10 +58,10 @@ function wrap(raw: object): object {
     get(target, key) {
       // Pass through the identity marker and non-string/number keys (symbols, etc.)
       if (key === IS_STORE) return true
-      if (typeof key === "symbol") return (target as Record<symbol, unknown>)[key]
+      if (typeof key === 'symbol') return (target as Record<symbol, unknown>)[key]
 
       // Array length — tracked via dedicated signal for push/pop/splice reactivity
-      if (isArray && key === "length") return lengthSig?.()
+      if (isArray && key === 'length') return lengthSig?.()
 
       // Non-own properties: prototype methods (forEach, map, push, …)
       // These must be returned untracked so array methods work normally.
@@ -74,7 +74,7 @@ function wrap(raw: object): object {
       const value = getOrCreateSignal(key)()
 
       // Deep reactivity: wrap nested objects/arrays transparently
-      if (value !== null && typeof value === "object") {
+      if (value !== null && typeof value === 'object') {
         return wrap(value as object)
       }
 
@@ -82,7 +82,7 @@ function wrap(raw: object): object {
     },
 
     set(target, key, value) {
-      if (typeof key === "symbol") {
+      if (typeof key === 'symbol') {
         ;(target as Record<symbol, unknown>)[key] = value
         return true
       }
@@ -91,7 +91,7 @@ function wrap(raw: object): object {
       ;(target as Record<PropertyKey, unknown>)[key] = value
 
       // Array length set directly (e.g. arr.length = 0)
-      if (isArray && key === "length") {
+      if (isArray && key === 'length') {
         lengthSig?.set(value as number)
         return true
       }
@@ -113,7 +113,7 @@ function wrap(raw: object): object {
 
     deleteProperty(target, key) {
       delete (target as Record<PropertyKey, unknown>)[key]
-      if (typeof key !== "symbol" && propSignals.has(key)) {
+      if (typeof key !== 'symbol' && propSignals.has(key)) {
         propSignals.get(key)?.set(undefined)
         propSignals.delete(key)
       }

package/src/tests/batch.test.ts

@@ -1,9 +1,9 @@
-import { batch, nextTick } from "../batch"
-import { effect } from "../effect"
-import { signal } from "../signal"
+import { batch, nextTick } from '../batch'
+import { effect } from '../effect'
+import { signal } from '../signal'
 
-describe("batch", () => {
-  test("defers notifications until end of batch", () => {
+describe('batch', () => {
+  test('defers notifications until end of batch', () => {
     const a = signal(1)
     const b = signal(2)
     let runs = 0
@@ -22,7 +22,7 @@ describe("batch", () => {
     expect(runs).toBe(2)
   })
 
-  test("effect sees final values after batch", () => {
+  test('effect sees final values after batch', () => {
     const s = signal(0)
     let seen = 0
     effect(() => {
@@ -36,7 +36,7 @@ describe("batch", () => {
     expect(seen).toBe(3)
   })
 
-  test("nested batches flush at outermost end", () => {
+  test('nested batches flush at outermost end', () => {
     const s = signal(0)
     let runs = 0
     effect(() => {
@@ -55,7 +55,7 @@ describe("batch", () => {
     expect(runs).toBe(2)
   })
 
-  test("batch propagates exceptions and still flushes", () => {
+  test('batch propagates exceptions and still flushes', () => {
     const s = signal(0)
     let seen = 0
     effect(() => {
@@ -66,15 +66,15 @@ describe("batch", () => {
     expect(() => {
       batch(() => {
         s.set(42)
-        throw new Error("boom")
+        throw new Error('boom')
       })
-    }).toThrow("boom")
+    }).toThrow('boom')
 
     // The batch should still have flushed notifications in the finally block
     expect(seen).toBe(42)
   })
 
-  test("batch with no signal changes is a no-op", () => {
+  test('batch with no signal changes is a no-op', () => {
     let runs = 0
     const s = signal(0)
     effect(() => {
@@ -89,7 +89,7 @@ describe("batch", () => {
     expect(runs).toBe(1)
   })
 
-  test("batch deduplicates same subscriber across multiple signals", () => {
+  test('batch deduplicates same subscriber across multiple signals', () => {
     const a = signal(1)
     const b = signal(2)
     let runs = 0
@@ -109,7 +109,7 @@ describe("batch", () => {
     expect(runs).toBe(2)
   })
 
-  test("notifications enqueued during flush land in alternate set", () => {
+  test('notifications enqueued during flush land in alternate set', () => {
     const a = signal(0)
     const b = signal(0)
     const log: string[] = []
@@ -128,11 +128,11 @@ describe("batch", () => {
       a.set(1)
     })
 
-    expect(log).toContain("a=1")
-    expect(log).toContain("b=10")
+    expect(log).toContain('a=1')
+    expect(log).toContain('b=10')
   })
 
-  test("nextTick resolves after microtasks flush", async () => {
+  test('nextTick resolves after microtasks flush', async () => {
     const s = signal(0)
     let seen = 0
     effect(() => {

package/src/tests/bind.test.ts

@@ -1,8 +1,8 @@
-import { _bind } from "../effect"
-import { signal } from "../signal"
+import { _bind } from '../effect'
+import { signal } from '../signal'
 
-describe("_bind (static-dep binding)", () => {
-  test("runs the function on first call and tracks deps", () => {
+describe('_bind (static-dep binding)', () => {
+  test('runs the function on first call and tracks deps', () => {
     const s = signal(0)
     let runs = 0
 
@@ -20,7 +20,7 @@ describe("_bind (static-dep binding)", () => {
     dispose()
   })
 
-  test("dispose stops re-runs", () => {
+  test('dispose stops re-runs', () => {
     const s = signal(0)
     let runs = 0
 
@@ -36,7 +36,7 @@ describe("_bind (static-dep binding)", () => {
     expect(runs).toBe(1) // no re-run
   })
 
-  test("dispose is idempotent", () => {
+  test('dispose is idempotent', () => {
     const s = signal(0)
     const dispose = _bind(() => {
       s()
@@ -46,7 +46,7 @@ describe("_bind (static-dep binding)", () => {
     dispose() // should not throw
   })
 
-  test("does not re-run after dispose even with multiple deps", () => {
+  test('does not re-run after dispose even with multiple deps', () => {
     const a = signal(0)
     const b = signal(0)
     let runs = 0
@@ -65,7 +65,7 @@ describe("_bind (static-dep binding)", () => {
     expect(runs).toBe(1)
   })
 
-  test("disposed run callback is a no-op", () => {
+  test('disposed run callback is a no-op', () => {
     const s = signal(0)
     let runs = 0
 

package/src/tests/branches.test.ts

@@ -1,19 +1,19 @@
 /**
  * Targeted tests for uncovered branches across reactivity package.
  */
-import { Cell } from "../cell"
-import { computed } from "../computed"
-import { createSelector } from "../createSelector"
-import { why } from "../debug"
-import { _bind, effect, renderEffect } from "../effect"
-import { reconcile } from "../reconcile"
-import { signal } from "../signal"
-import { createStore, isStore } from "../store"
+import { Cell } from '../cell'
+import { computed } from '../computed'
+import { createSelector } from '../createSelector'
+import { why } from '../debug'
+import { _bind, effect, renderEffect } from '../effect'
+import { reconcile } from '../reconcile'
+import { signal } from '../signal'
+import { createStore, isStore } from '../store'
 
 // ── cell.ts branches: promote listener to Set ─────────────────────────────────
 
-describe("Cell listener promotion", () => {
-  test("promotes single listener to Set when second listener added", () => {
+describe('Cell listener promotion', () => {
+  test('promotes single listener to Set when second listener added', () => {
     const c = new Cell(0)
     const calls: number[] = []
     c.listen(() => calls.push(1))
@@ -24,7 +24,7 @@ describe("Cell listener promotion", () => {
     expect(calls).toEqual([1, 2, 3])
   })
 
-  test("subscribe unsubscribes single listener", () => {
+  test('subscribe unsubscribes single listener', () => {
     const c = new Cell(0)
     const calls: number[] = []
     const unsub = c.subscribe(() => calls.push(1))
@@ -36,7 +36,7 @@ describe("Cell listener promotion", () => {
     expect(calls).toEqual([1])
   })
 
-  test("subscribe unsubscribes from Set", () => {
+  test('subscribe unsubscribes from Set', () => {
     const c = new Cell(0)
     const calls: number[] = []
     c.listen(() => calls.push(1))
@@ -48,7 +48,7 @@ describe("Cell listener promotion", () => {
     expect(calls).toEqual([1, 2, 1])
   })
 
-  test("promote to Set when _l was unsubscribed (null _l, null _s)", () => {
+  test('promote to Set when _l was unsubscribed (null _l, null _s)', () => {
     const c = new Cell(0)
     const fn1 = () => {}
     // subscribe sets _l, unsub sets _l to null
@@ -62,7 +62,7 @@ describe("Cell listener promotion", () => {
     c.set(1)
   })
 
-  test("double unsubscribe from single listener is safe", () => {
+  test('double unsubscribe from single listener is safe', () => {
     const c = new Cell(0)
     const fn1 = () => {}
     const unsub = c.subscribe(fn1)
@@ -74,8 +74,8 @@ describe("Cell listener promotion", () => {
 
 // ── computed.ts branches ──────────────────────────────────────────────────────
 
-describe("computed branches", () => {
-  test("disposed computed does not recompute", () => {
+describe('computed branches', () => {
+  test('disposed computed does not recompute', () => {
     const s = signal(1)
     const c = computed(() => s() * 2, { equals: Object.is })
     expect(c()).toBe(2)
@@ -85,7 +85,7 @@ describe("computed branches", () => {
     // (it may return stale value or throw — just ensure no crash)
   })
 
-  test("computed with custom equals and subscribers", () => {
+  test('computed with custom equals and subscribers', () => {
     const s = signal(1)
     const c = computed(() => s() * 2, { equals: Object.is })
     const values: number[] = []
@@ -100,7 +100,7 @@ describe("computed branches", () => {
     expect(values).toEqual([2, 4])
   })
 
-  test("computed without custom equals notifies subscribers on dep change", () => {
+  test('computed without custom equals notifies subscribers on dep change', () => {
     const s = signal(1)
     const c = computed(() => s() * 2)
     const values: number[] = []
@@ -115,73 +115,73 @@ describe("computed branches", () => {
 
 // ── createSelector.ts branches ────────────────────────────────────────────────
 
-describe("createSelector branches", () => {
-  test("selector with no matching bucket on old value", () => {
-    const s = signal<string>("a")
+describe('createSelector branches', () => {
+  test('selector with no matching bucket on old value', () => {
+    const s = signal<string>('a')
     const isSelected = createSelector(s)
     // Read "a" — creates bucket for "a"
     effect(() => {
-      isSelected("a")
+      isSelected('a')
     })
     // Change to "b" — old bucket "a" exists, new bucket "b" does not
-    s.set("b")
+    s.set('b')
   })
 
-  test("selector reuses existing host for same value", () => {
-    const s = signal<string>("a")
+  test('selector reuses existing host for same value', () => {
+    const s = signal<string>('a')
     const isSelected = createSelector(s)
     const results: boolean[] = []
     effect(() => {
-      results.push(isSelected("a"))
+      results.push(isSelected('a'))
     })
     // This second effect creates another subscription to same bucket
     effect(() => {
-      results.push(isSelected("a"))
+      results.push(isSelected('a'))
     })
     expect(results).toEqual([true, true])
-    s.set("b")
+    s.set('b')
     // Both should see false
     expect(results).toEqual([true, true, false, false])
   })
 
-  test("selector handles Object.is equality (no change)", () => {
-    const s = signal<string>("a")
+  test('selector handles Object.is equality (no change)', () => {
+    const s = signal<string>('a')
     const isSelected = createSelector(s)
     let count = 0
     effect(() => {
-      isSelected("a")
+      isSelected('a')
       count++
     })
     expect(count).toBe(1)
     // Same value — Object.is check should skip
-    s.set("a")
+    s.set('a')
     expect(count).toBe(1)
   })
 
-  test("selector query for value with no existing bucket creates one", () => {
-    const s = signal<string>("a")
+  test('selector query for value with no existing bucket creates one', () => {
+    const s = signal<string>('a')
     const isSelected = createSelector(s)
     // Query outside effect — creates a bucket for "z" that has no subscribers
-    const result = isSelected("z")
+    const result = isSelected('z')
     expect(result).toBe(false)
   })
 
-  test("selector change when old value has no subscriber bucket", () => {
-    const s = signal<string>("a")
+  test('selector change when old value has no subscriber bucket', () => {
+    const s = signal<string>('a')
     const isSelected = createSelector(s)
     // Only subscribe to "b", not "a"
     effect(() => {
-      isSelected("b")
+      isSelected('b')
     })
     // Change from "a" to "b" — old value "a" has no bucket (never queried in effect)
-    s.set("b")
+    s.set('b')
   })
 })
 
 // ── effect.ts branches ────────────────────────────────────────────────────────
 
-describe("effect disposed branches", () => {
-  test("disposed effect does not re-run", () => {
+describe('effect disposed branches', () => {
+  test('disposed effect does not re-run', () => {
     const s = signal(0)
     let count = 0
     const e = effect(() => {
@@ -194,7 +194,7 @@ describe("effect disposed branches", () => {
     expect(count).toBe(1)
   })
 
-  test("disposed _bind does not re-run", () => {
+  test('disposed _bind does not re-run', () => {
     const s = signal(0)
     let count = 0
     const dispose = _bind(() => {
@@ -209,7 +209,7 @@ describe("effect disposed branches", () => {
     dispose()
   })
 
-  test("disposed renderEffect does not re-run", () => {
+  test('disposed renderEffect does not re-run', () => {
     const s = signal(0)
     let count = 0
     const dispose = renderEffect(() => {
@@ -225,27 +225,27 @@ describe("effect disposed branches", () => {
 
 // ── store.ts branches ─────────────────────────────────────────────────────────
 
-describe("store branches", () => {
-  test("setting symbol property", () => {
+describe('store branches', () => {
+  test('setting symbol property', () => {
     const store = createStore({ a: 1 })
-    const sym = Symbol("test")
-    ;(store as Record<symbol, unknown>)[sym] = "hello"
-    expect((store as Record<symbol, unknown>)[sym]).toBe("hello")
+    const sym = Symbol('test')
+    ;(store as Record<symbol, unknown>)[sym] = 'hello'
+    expect((store as Record<symbol, unknown>)[sym]).toBe('hello')
   })
 
-  test("deleteProperty on store", () => {
+  test('deleteProperty on store', () => {
     const store = createStore<Record<string, unknown>>({ a: 1, b: 2 })
     delete store.b
     expect(store.b).toBeUndefined()
   })
 
-  test("deleteProperty on store array", () => {
+  test('deleteProperty on store array', () => {
     const store = createStore([1, 2, 3])
-    delete (store as unknown as Record<string, unknown>)["1"]
+    delete (store as unknown as Record<string, unknown>)['1']
     expect(store[1]).toBeUndefined()
   })
 
-  test("deleteProperty on store with reactive subscriber", () => {
+  test('deleteProperty on store with reactive subscriber', () => {
     const store = createStore<Record<string, unknown>>({ a: 1, b: 2 })
     // Read 'b' in effect to create propSignal
     let val: unknown
@@ -261,14 +261,14 @@ describe("store branches", () => {
 
 // ── reconcile.ts branches ─────────────────────────────────────────────────────
 
-describe("reconcile branches", () => {
-  test("reconcile array with non-object source items", () => {
+describe('reconcile branches', () => {
+  test('reconcile array with non-object source items', () => {
     const store = createStore([1, 2, 3])
     reconcile([4, 5], store)
     expect([...store]).toEqual([4, 5])
   })
 
-  test("reconcile object with raw (non-store) target value", () => {
+  test('reconcile object with raw (non-store) target value', () => {
     // Create store where nested value isn't yet a store proxy
     const store = createStore<Record<string, unknown>>({ a: 1 })
     // Reconcile with nested object — target.a is a number (not store), so it takes the else branch
@@ -276,26 +276,26 @@ describe("reconcile branches", () => {
     expect((store.a as Record<string, unknown>).nested).toBe(true)
   })
 
-  test("reconcile array with null source entries", () => {
+  test('reconcile array with null source entries', () => {
     const store = createStore([1, null, 3])
     reconcile([null, 2, null], store)
     expect([...store]).toEqual([null, 2, null])
   })
 
-  test("reconcile object with null source values", () => {
+  test('reconcile object with null source values', () => {
     const store = createStore<Record<string, unknown>>({ a: { x: 1 }, b: 2 })
     reconcile({ a: null, b: 2 }, store)
     expect(store.a).toBeNull()
   })
 
-  test("reconcile array with both source and target as objects (recursive)", () => {
+  test('reconcile array with both source and target as objects (recursive)', () => {
     const store = createStore([{ a: 1 }, { b: 2 }])
     reconcile([{ a: 10 }, { b: 20 }], store)
     expect(store[0]?.a).toBe(10)
     expect(store[1]?.b).toBe(20)
   })
 
-  test("reconcile object where target has store-proxied nested object", () => {
+  test('reconcile object where target has store-proxied nested object', () => {
     const store = createStore<Record<string, Record<string, number>>>({ nested: { x: 1 } })
     // Access nested to ensure it's proxied as store
     const _val = store.nested?.x
@@ -304,7 +304,7 @@ describe("reconcile branches", () => {
     expect(store.nested?.x).toBe(99)
   })
 
-  test("reconcile object where target has raw (non-store) nested object", () => {
+  test('reconcile object where target has raw (non-store) nested object', () => {
     // Don't access nested, so it stays as raw object (not proxied)
     const store = createStore<Record<string, Record<string, number>>>({ nested: { x: 1 } })
     // nested has not been accessed via proxy, so isStore(target.nested) is false
@@ -316,25 +316,25 @@ describe("reconcile branches", () => {
 
 // ── debug.ts branches ─────────────────────────────────────────────────────────
 
-describe("debug branches", () => {
-  test("why with exactly 1 subscriber shows singular", async () => {
-    const s = signal(0, { name: "single" })
+describe('debug branches', () => {
+  test('why with exactly 1 subscriber shows singular', async () => {
+    const s = signal(0, { name: 'single' })
     // Add exactly 1 subscriber
     effect(() => {
       s()
     })
     const logs: string[] = []
     const origLog = console.log
-    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    console.log = (...args: unknown[]) => logs.push(args.join(' '))
     why()
     s.set(1)
     // why() auto-disposes via microtask
     await new Promise((r) => setTimeout(r, 10))
     console.log = origLog
-    expect(logs.some((l) => l.includes("1 subscriber"))).toBe(true)
+    expect(logs.some((l) => l.includes('1 subscriber'))).toBe(true)
   })
 
-  test("_notifyTraceListeners with no active listeners is noop", () => {
+  test('_notifyTraceListeners with no active listeners is noop', () => {
     // When no listeners registered, this should not throw
     // (tests the early return / null check)
     const s = signal(0)