@pyreon/reactivity 0.1.0

package/src/store.ts

@@ -0,0 +1,139 @@
+/**
+ * createStore — deep reactive Proxy store.
+ *
+ * Wraps a plain object/array in a Proxy that creates a fine-grained signal for
+ * every property. Direct mutations (`store.count++`, `store.items[0].label = "x"`)
+ * trigger only the signals for the mutated properties — not the whole tree.
+ *
+ * @example
+ * const state = createStore({ count: 0, items: [{ id: 1, text: "hello" }] })
+ *
+ * effect(() => console.log(state.count))  // tracks state.count only
+ * state.count++                           // only the count effect re-runs
+ * state.items[0].text = "world"           // only text-tracking effects re-run
+ */
+
+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")
+
+/** Returns true if the value is a createStore proxy. */
+export function isStore(value: unknown): boolean {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    (value as Record<symbol, unknown>)[IS_STORE] === true
+  )
+}
+
+/**
+ * Create a deep reactive store from a plain object or array.
+ * Returns a proxy — mutations to the proxy trigger fine-grained reactive updates.
+ */
+export function createStore<T extends object>(initial: T): T {
+  return wrap(initial) as T
+}
+
+function wrap(raw: object): object {
+  const cached = proxyCache.get(raw)
+  if (cached) return cached
+
+  // Per-property signals. Lazily created on first access.
+  const propSignals = new Map<PropertyKey, Signal<unknown>>()
+  // For arrays: track length changes separately (push/pop/splice affect length)
+  const isArray = Array.isArray(raw)
+  const lengthSig = isArray ? signal((raw as unknown[]).length) : null
+
+  function getOrCreateSignal(key: PropertyKey): Signal<unknown> {
+    if (!propSignals.has(key)) {
+      propSignals.set(key, signal((raw as Record<PropertyKey, unknown>)[key]))
+    }
+    return propSignals.get(key) as Signal<unknown>
+  }
+
+  const proxy = new Proxy(raw, {
+    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]
+
+      // Array length — tracked via dedicated signal for push/pop/splice reactivity
+      if (isArray && key === "length") return lengthSig?.()
+
+      // Non-own properties: prototype methods (forEach, map, push, …)
+      // These must be returned untracked so array methods work normally.
+      // Array methods will then go through set/get on indices via the proxy.
+      if (!Object.hasOwn(target, key)) {
+        return (target as Record<PropertyKey, unknown>)[key]
+      }
+
+      // Track via per-property signal
+      const value = getOrCreateSignal(key)()
+
+      // Deep reactivity: wrap nested objects/arrays transparently
+      if (value !== null && typeof value === "object") {
+        return wrap(value as object)
+      }
+
+      return value
+    },
+
+    set(target, key, value) {
+      if (typeof key === "symbol") {
+        ;(target as Record<symbol, unknown>)[key] = value
+        return true
+      }
+
+      const prevLength = isArray ? (target as unknown[]).length : 0
+      ;(target as Record<PropertyKey, unknown>)[key] = value
+
+      // Array length set directly (e.g. arr.length = 0)
+      if (isArray && key === "length") {
+        lengthSig?.set(value as number)
+        return true
+      }
+
+      // Update or create signal for this property
+      if (propSignals.has(key)) {
+        propSignals.get(key)?.set(value)
+      } else {
+        propSignals.set(key, signal(value))
+      }
+
+      // If array length changed (e.g. via push/splice index assignment), update it
+      if (isArray && (target as unknown[]).length !== prevLength) {
+        lengthSig?.set((target as unknown[]).length)
+      }
+
+      return true
+    },
+
+    deleteProperty(target, key) {
+      delete (target as Record<PropertyKey, unknown>)[key]
+      if (typeof key !== "symbol" && propSignals.has(key)) {
+        propSignals.get(key)?.set(undefined)
+        propSignals.delete(key)
+      }
+      if (isArray) lengthSig?.set((target as unknown[]).length)
+      return true
+    },
+
+    has(target, key) {
+      return Reflect.has(target, key)
+    },
+
+    ownKeys(target) {
+      return Reflect.ownKeys(target)
+    },
+
+    getOwnPropertyDescriptor(target, key) {
+      return Reflect.getOwnPropertyDescriptor(target, key)
+    },
+  })
+
+  proxyCache.set(raw, proxy)
+  return proxy
+}

package/src/tests/batch.test.ts

@@ -0,0 +1,69 @@
+import { batch, nextTick } from "../batch"
+import { effect } from "../effect"
+import { signal } from "../signal"
+
+describe("batch", () => {
+  test("defers notifications until end of batch", () => {
+    const a = signal(1)
+    const b = signal(2)
+    let runs = 0
+    effect(() => {
+      a()
+      b()
+      runs++
+    })
+    expect(runs).toBe(1) // initial run
+
+    batch(() => {
+      a.set(10)
+      b.set(20)
+    })
+    // should only re-run once despite two updates
+    expect(runs).toBe(2)
+  })
+
+  test("effect sees final values after batch", () => {
+    const s = signal(0)
+    let seen = 0
+    effect(() => {
+      seen = s()
+    })
+    batch(() => {
+      s.set(1)
+      s.set(2)
+      s.set(3)
+    })
+    expect(seen).toBe(3)
+  })
+
+  test("nested batches flush at outermost end", () => {
+    const s = signal(0)
+    let runs = 0
+    effect(() => {
+      s()
+      runs++
+    })
+    expect(runs).toBe(1)
+
+    batch(() => {
+      batch(() => {
+        s.set(1)
+        s.set(2)
+      })
+      s.set(3)
+    })
+    expect(runs).toBe(2)
+  })
+
+  test("nextTick resolves after microtasks flush", async () => {
+    const s = signal(0)
+    let seen = 0
+    effect(() => {
+      seen = s()
+    })
+
+    s.set(42)
+    await nextTick()
+    expect(seen).toBe(42)
+  })
+})

package/src/tests/bind.test.ts

@@ -0,0 +1,84 @@
+import { _bind } from "../effect"
+import { signal } from "../signal"
+
+describe("_bind (static-dep binding)", () => {
+  test("runs the function on first call and tracks deps", () => {
+    const s = signal(0)
+    let runs = 0
+
+    const dispose = _bind(() => {
+      s()
+      runs++
+    })
+
+    expect(runs).toBe(1)
+
+    // Deps tracked on first run, re-runs on signal change
+    s.set(1)
+    expect(runs).toBe(2)
+
+    dispose()
+  })
+
+  test("dispose stops re-runs", () => {
+    const s = signal(0)
+    let runs = 0
+
+    const dispose = _bind(() => {
+      s()
+      runs++
+    })
+
+    expect(runs).toBe(1)
+
+    dispose()
+    s.set(1)
+    expect(runs).toBe(1) // no re-run
+  })
+
+  test("dispose is idempotent", () => {
+    const s = signal(0)
+    const dispose = _bind(() => {
+      s()
+    })
+
+    dispose()
+    dispose() // should not throw
+  })
+
+  test("does not re-run after dispose even with multiple deps", () => {
+    const a = signal(0)
+    const b = signal(0)
+    let runs = 0
+
+    const dispose = _bind(() => {
+      a()
+      b()
+      runs++
+    })
+
+    expect(runs).toBe(1)
+
+    dispose()
+    a.set(1)
+    b.set(1)
+    expect(runs).toBe(1)
+  })
+
+  test("disposed run callback is a no-op", () => {
+    const s = signal(0)
+    let runs = 0
+
+    const dispose = _bind(() => {
+      s()
+      runs++
+    })
+
+    expect(runs).toBe(1)
+
+    // Dispose then trigger — the run function should bail out
+    dispose()
+    s.set(5)
+    expect(runs).toBe(1)
+  })
+})

package/src/tests/branches.test.ts

@@ -0,0 +1,343 @@
+/**
+ * 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"
+
+// ── cell.ts branches: promote listener to Set ─────────────────────────────────
+
+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))
+    c.listen(() => calls.push(2))
+    // Third listen: _s already exists (false branch of `if (!this._s)`)
+    c.listen(() => calls.push(3))
+    c.set(1)
+    expect(calls).toEqual([1, 2, 3])
+  })
+
+  test("subscribe unsubscribes single listener", () => {
+    const c = new Cell(0)
+    const calls: number[] = []
+    const unsub = c.subscribe(() => calls.push(1))
+    c.set(1)
+    expect(calls).toEqual([1])
+    unsub()
+    c.set(2)
+    // Should not fire after unsubscribe
+    expect(calls).toEqual([1])
+  })
+
+  test("subscribe unsubscribes from Set", () => {
+    const c = new Cell(0)
+    const calls: number[] = []
+    c.listen(() => calls.push(1))
+    const unsub = c.subscribe(() => calls.push(2))
+    c.set(1)
+    expect(calls).toEqual([1, 2])
+    unsub()
+    c.set(2)
+    expect(calls).toEqual([1, 2, 1])
+  })
+
+  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
+    const unsub = c.subscribe(fn1)
+    unsub()
+    // Now _l is null and _s is null — next listen goes to fast path (!_l && !_s)
+    const fn2 = () => {}
+    c.listen(fn2)
+    // Add another to force promotion — _l is fn2, _s is null → promotes with _l
+    c.listen(() => {})
+    c.set(1)
+  })
+
+  test("double unsubscribe from single listener is safe", () => {
+    const c = new Cell(0)
+    const fn1 = () => {}
+    const unsub = c.subscribe(fn1)
+    unsub()
+    // Second call — _l is null, so `this._l === listener` is false
+    unsub()
+  })
+})
+
+// ── computed.ts branches ──────────────────────────────────────────────────────
+
+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)
+    c.dispose()
+    s.set(5)
+    // After dispose, the computed should not update
+    // (it may return stale value or throw — just ensure no crash)
+  })
+
+  test("computed with custom equals and subscribers", () => {
+    const s = signal(1)
+    const c = computed(() => s() * 2, { equals: Object.is })
+    const values: number[] = []
+    effect(() => {
+      values.push(c())
+    })
+    expect(values).toEqual([2])
+    s.set(2)
+    expect(values).toEqual([2, 4])
+    // Same value — should not notify
+    s.set(2)
+    expect(values).toEqual([2, 4])
+  })
+
+  test("computed without custom equals notifies subscribers on dep change", () => {
+    const s = signal(1)
+    const c = computed(() => s() * 2)
+    const values: number[] = []
+    effect(() => {
+      values.push(c())
+    })
+    expect(values).toEqual([2])
+    s.set(2)
+    expect(values).toEqual([2, 4])
+  })
+})
+
+// ── createSelector.ts branches ────────────────────────────────────────────────
+
+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")
+    })
+    // Change to "b" — old bucket "a" exists, new bucket "b" does not
+    s.set("b")
+  })
+
+  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"))
+    })
+    // This second effect creates another subscription to same bucket
+    effect(() => {
+      results.push(isSelected("a"))
+    })
+    expect(results).toEqual([true, true])
+    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")
+    const isSelected = createSelector(s)
+    let count = 0
+    effect(() => {
+      isSelected("a")
+      count++
+    })
+    expect(count).toBe(1)
+    // Same value — Object.is check should skip
+    s.set("a")
+    expect(count).toBe(1)
+  })
+
+  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")
+    expect(result).toBe(false)
+  })
+
+  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")
+    })
+    // Change from "a" to "b" — old value "a" has no bucket (never queried in effect)
+    s.set("b")
+  })
+})
+
+// ── effect.ts branches ────────────────────────────────────────────────────────
+
+describe("effect disposed branches", () => {
+  test("disposed effect does not re-run", () => {
+    const s = signal(0)
+    let count = 0
+    const e = effect(() => {
+      s()
+      count++
+    })
+    expect(count).toBe(1)
+    e.dispose()
+    s.set(1)
+    expect(count).toBe(1)
+  })
+
+  test("disposed _bind does not re-run", () => {
+    const s = signal(0)
+    let count = 0
+    const dispose = _bind(() => {
+      s()
+      count++
+    })
+    expect(count).toBe(1)
+    dispose()
+    s.set(1)
+    expect(count).toBe(1)
+    // Double dispose is safe
+    dispose()
+  })
+
+  test("disposed renderEffect does not re-run", () => {
+    const s = signal(0)
+    let count = 0
+    const dispose = renderEffect(() => {
+      s()
+      count++
+    })
+    expect(count).toBe(1)
+    dispose()
+    s.set(1)
+    expect(count).toBe(1)
+  })
+})
+
+// ── store.ts branches ─────────────────────────────────────────────────────────
+
+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")
+  })
+
+  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", () => {
+    const store = createStore([1, 2, 3])
+    delete (store as unknown as Record<string, unknown>)["1"]
+    expect(store[1]).toBeUndefined()
+  })
+
+  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
+    effect(() => {
+      val = store.b
+    })
+    expect(val).toBe(2)
+    delete store.b
+    // Signal should be set to undefined and deleted from map
+    expect(val).toBeUndefined()
+  })
+})
+
+// ── reconcile.ts branches ─────────────────────────────────────────────────────
+
+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", () => {
+    // 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
+    reconcile({ a: { nested: true } }, store)
+    expect((store.a as Record<string, unknown>).nested).toBe(true)
+  })
+
+  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", () => {
+    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)", () => {
+    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", () => {
+    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
+    expect(isStore(store.nested!)).toBe(true)
+    reconcile({ nested: { x: 99 } }, store)
+    expect(store.nested?.x).toBe(99)
+  })
+
+  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
+    // This should hit the `else { target[key] = sv }` branch at line 78
+    reconcile({ nested: { x: 99 } }, store)
+    expect(store.nested?.x).toBe(99)
+  })
+})
+
+// ── debug.ts branches ─────────────────────────────────────────────────────────
+
+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(" "))
+    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)
+  })
+
+  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)
+    s.set(1) // triggers _notifyTraceListeners internally but no listeners active
+  })
+})