@pyreon/reactivity 0.1.0

package/src/tests/cell.test.ts

@@ -0,0 +1,111 @@
+import { Cell, cell } from "../cell"
+
+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() skips when value is the same (Object.is)", () => {
+    const c = cell(1)
+    let calls = 0
+    c.listen(() => calls++)
+    c.set(1)
+    expect(calls).toBe(0)
+  })
+
+  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")
+    let fired = false
+    c.listen(() => {
+      fired = true
+    })
+    c.set("b")
+    expect(fired).toBe(true)
+  })
+
+  test("listen() single-listener fast path (no Set allocated)", () => {
+    const c = cell(0)
+    let count = 0
+    c.listen(() => count++)
+    // Should use _l fast path, not _s Set
+    expect(c._s).toBeNull()
+    expect(c._l).not.toBeNull()
+    c.set(1)
+    expect(count).toBe(1)
+  })
+
+  test("listen() promotes to Set with multiple listeners", () => {
+    const c = cell(0)
+    let a = 0
+    let b = 0
+    c.listen(() => a++)
+    c.listen(() => b++)
+    expect(c._s).not.toBeNull()
+    expect(c._l).toBeNull()
+    c.set(1)
+    expect(a).toBe(1)
+    expect(b).toBe(1)
+  })
+
+  test("subscribe() returns working unsubscribe (single listener)", () => {
+    const c = cell(0)
+    let count = 0
+    const unsub = c.subscribe(() => count++)
+    c.set(1)
+    expect(count).toBe(1)
+    unsub()
+    c.set(2)
+    expect(count).toBe(1) // no more notifications
+  })
+
+  test("subscribe() returns working unsubscribe (multi listener)", () => {
+    const c = cell(0)
+    let a = 0
+    let b = 0
+    c.listen(() => a++)
+    const unsub = c.subscribe(() => b++)
+    c.set(1)
+    expect(a).toBe(1)
+    expect(b).toBe(1)
+    unsub()
+    c.set(2)
+    expect(a).toBe(2)
+    expect(b).toBe(1) // unsubscribed
+  })
+
+  test("cell() factory returns Cell instance", () => {
+    const c = cell("x")
+    expect(c).toBeInstanceOf(Cell)
+  })
+
+  test("multiple rapid updates notify correctly", () => {
+    const c = cell(0)
+    const values: number[] = []
+    c.listen(() => values.push(c.peek()))
+    c.set(1)
+    c.set(2)
+    c.set(3)
+    expect(values).toEqual([1, 2, 3])
+  })
+
+  test("NaN equality (Object.is)", () => {
+    const c = cell(Number.NaN)
+    let calls = 0
+    c.listen(() => calls++)
+    c.set(Number.NaN)
+    expect(calls).toBe(0) // Object.is(NaN, NaN) is true
+  })
+})

package/src/tests/computed.test.ts

@@ -0,0 +1,146 @@
+import { computed } from "../computed"
+import { effect } from "../effect"
+import { signal } from "../signal"
+
+describe("computed", () => {
+  test("computes derived value", () => {
+    const s = signal(2)
+    const doubled = computed(() => s() * 2)
+    expect(doubled()).toBe(4)
+  })
+
+  test("updates when dependency changes", () => {
+    const s = signal(3)
+    const tripled = computed(() => s() * 3)
+    expect(tripled()).toBe(9)
+    s.set(4)
+    expect(tripled()).toBe(12)
+  })
+
+  test("is lazy — does not compute until read", () => {
+    let computations = 0
+    const s = signal(0)
+    const c = computed(() => {
+      computations++
+      return s() + 1
+    })
+    expect(computations).toBe(0)
+    c() // first read
+    expect(computations).toBe(1)
+  })
+
+  test("is memoized — does not recompute on repeated reads", () => {
+    let computations = 0
+    const s = signal(5)
+    const c = computed(() => {
+      computations++
+      return s() * 2
+    })
+    c()
+    c()
+    c()
+    expect(computations).toBe(1)
+  })
+
+  test("recomputes only when dirty", () => {
+    let computations = 0
+    const s = signal(1)
+    const c = computed(() => {
+      computations++
+      return s()
+    })
+    c()
+    expect(computations).toBe(1)
+    s.set(2)
+    c()
+    expect(computations).toBe(2)
+    c()
+    expect(computations).toBe(2) // still memoized
+  })
+
+  test("chains correctly", () => {
+    const base = signal(2)
+    const doubled = computed(() => base() * 2)
+    const quadrupled = computed(() => doubled() * 2)
+    expect(quadrupled()).toBe(8)
+    base.set(3)
+    expect(quadrupled()).toBe(12)
+  })
+
+  test("dispose stops recomputation", () => {
+    const s = signal(1)
+    let computations = 0
+    const c = computed(() => {
+      computations++
+      return s() * 2
+    })
+    c() // initial
+    expect(computations).toBe(1)
+    c.dispose()
+    s.set(2)
+    // After dispose, reading returns stale value and does not recompute
+    // (the computed is no longer subscribed to s)
+  })
+
+  test("custom equals skips downstream notification when equal", () => {
+    const s = signal(3)
+    let downstream = 0
+
+    const c = computed(() => Math.floor(s() / 10), {
+      equals: (a, b) => a === b,
+    })
+
+    effect(() => {
+      c()
+      downstream++
+    })
+
+    expect(downstream).toBe(1)
+    expect(c()).toBe(0)
+
+    s.set(5) // Math.floor(5/10) = 0, same as before
+    expect(downstream).toBe(1) // no downstream update
+
+    s.set(15) // Math.floor(15/10) = 1, different
+    expect(downstream).toBe(2)
+    expect(c()).toBe(1)
+  })
+
+  test("custom equals with array comparison", () => {
+    const items = signal([1, 2, 3])
+    let downstream = 0
+
+    const sorted = computed(() => items().slice().sort(), {
+      equals: (a, b) => a.length === b.length && a.every((v, i) => v === b[i]),
+    })
+
+    effect(() => {
+      sorted()
+      downstream++
+    })
+
+    expect(downstream).toBe(1)
+
+    // Set to same content in different array — equals returns true, no notification
+    items.set([1, 2, 3])
+    expect(downstream).toBe(1)
+
+    // Actually different content
+    items.set([1, 2, 4])
+    expect(downstream).toBe(2)
+  })
+
+  test("computed used as dependency inside an effect (subscribe path)", () => {
+    const s = signal(10)
+    const c = computed(() => s() + 1)
+    let result = 0
+
+    effect(() => {
+      result = c()
+    })
+
+    expect(result).toBe(11)
+    s.set(20)
+    expect(result).toBe(21)
+  })
+})

package/src/tests/createSelector.test.ts

@@ -0,0 +1,119 @@
+import { createSelector } from "../createSelector"
+import { effect } from "../effect"
+import { signal } from "../signal"
+
+describe("createSelector", () => {
+  test("returns true for the currently selected value", () => {
+    const selected = signal(1)
+    const isSelected = createSelector(() => selected())
+
+    let result = false
+    effect(() => {
+      result = isSelected(1)
+    })
+    expect(result).toBe(true)
+  })
+
+  test("returns false for non-selected values", () => {
+    const selected = signal(1)
+    const isSelected = createSelector(() => selected())
+
+    let result = true
+    effect(() => {
+      result = isSelected(2)
+    })
+    expect(result).toBe(false)
+  })
+
+  test("only notifies affected subscribers when selection changes", () => {
+    const selected = signal(1)
+    const isSelected = createSelector(() => selected())
+
+    let runs1 = 0
+    let runs2 = 0
+    let runs3 = 0
+
+    effect(() => {
+      isSelected(1)
+      runs1++
+    })
+    effect(() => {
+      isSelected(2)
+      runs2++
+    })
+    effect(() => {
+      isSelected(3)
+      runs3++
+    })
+
+    expect(runs1).toBe(1)
+    expect(runs2).toBe(1)
+    expect(runs3).toBe(1)
+
+    // Change selection from 1 to 2: only buckets 1 (deselected) and 2 (newly selected) should fire
+    selected.set(2)
+    expect(runs1).toBe(2) // deselected
+    expect(runs2).toBe(2) // newly selected
+    expect(runs3).toBe(1) // unaffected
+  })
+
+  test("does not notify when source changes to the same value", () => {
+    const selected = signal(1)
+    const isSelected = createSelector(() => selected())
+
+    let runs = 0
+    effect(() => {
+      isSelected(1)
+      runs++
+    })
+
+    selected.set(1) // same value
+    expect(runs).toBe(1)
+  })
+
+  test("works when changing to a value with no subscribers", () => {
+    const selected = signal(1)
+    const isSelected = createSelector(() => selected())
+
+    let runs = 0
+    effect(() => {
+      isSelected(1)
+      runs++
+    })
+
+    // Change to value 99 which has no subscriber bucket
+    selected.set(99)
+    expect(runs).toBe(2) // old bucket (1) notified
+  })
+
+  test("reuses host objects for the same value", () => {
+    const selected = signal(1)
+    const isSelected = createSelector(() => selected())
+
+    let result1 = false
+    let result2 = false
+    effect(() => {
+      result1 = isSelected(1)
+    })
+    // Second call with same value should reuse the host
+    effect(() => {
+      result2 = isSelected(1)
+    })
+
+    expect(result1).toBe(true)
+    expect(result2).toBe(true)
+
+    selected.set(2)
+    expect(result1).toBe(false)
+    expect(result2).toBe(false)
+  })
+
+  test("tracks correctly outside an effect (no activeEffect)", () => {
+    const selected = signal(1)
+    const isSelected = createSelector(() => selected())
+
+    // Calling outside an effect should still return the correct boolean
+    expect(isSelected(1)).toBe(true)
+    expect(isSelected(2)).toBe(false)
+  })
+})

package/src/tests/debug.test.ts

@@ -0,0 +1,196 @@
+import { _notifyTraceListeners, inspectSignal, isTracing, onSignalUpdate, why } from "../debug"
+import { signal } from "../signal"
+
+describe("debug", () => {
+  describe("onSignalUpdate / isTracing", () => {
+    test("isTracing is false by default", () => {
+      expect(isTracing()).toBe(false)
+    })
+
+    test("registering a listener enables tracing", () => {
+      const dispose = onSignalUpdate(() => {})
+      expect(isTracing()).toBe(true)
+      dispose()
+      expect(isTracing()).toBe(false)
+    })
+
+    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" })
+      s.set(2)
+
+      expect(events.length).toBe(1)
+      expect(events[0]).toEqual({ name: "count", prev: 1, next: 2 })
+
+      dispose()
+    })
+
+    test("dispose removes only the specific listener", () => {
+      let calls1 = 0
+      let calls2 = 0
+      const dispose1 = onSignalUpdate(() => calls1++)
+      const dispose2 = onSignalUpdate(() => calls2++)
+
+      const s = signal(0)
+      s.set(1)
+      expect(calls1).toBe(1)
+      expect(calls2).toBe(1)
+
+      dispose1()
+
+      s.set(2)
+      expect(calls1).toBe(1) // removed
+      expect(calls2).toBe(2) // still active
+
+      dispose2()
+      expect(isTracing()).toBe(false)
+    })
+
+    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", () => {
+      const s = signal(0)
+      // Should not throw
+      _notifyTraceListeners(s, 0, 1)
+    })
+
+    test("event includes stack and timestamp", () => {
+      let event: { stack: string; timestamp: number } | undefined
+      const dispose = onSignalUpdate((e) => {
+        event = { stack: e.stack, timestamp: e.timestamp }
+      })
+
+      const s = signal(0)
+      s.set(1)
+
+      expect(event).toBeDefined()
+      expect(typeof event?.stack).toBe("string")
+      expect(typeof event?.timestamp).toBe("number")
+
+      dispose()
+    })
+  })
+
+  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" })
+      why()
+      s.set(2)
+
+      // Wait for microtask (auto-dispose)
+      await new Promise((r) => queueMicrotask(() => r(undefined)))
+
+      expect(logs.length).toBeGreaterThan(0)
+      console.log = origLog
+    })
+
+    test("logs 'no updates' when nothing changes", async () => {
+      const logs: unknown[][] = []
+      const origLog = console.log
+      console.log = (...args: unknown[]) => logs.push(args)
+
+      why()
+      // No signal updates
+
+      await new Promise((r) => queueMicrotask(() => r(undefined)))
+
+      const noUpdateLog =
+        logs.find((args) =>
+          typeof args[0] === "string" ? args[0].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 () => {
+      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" })
+      s.set(1)
+
+      await new Promise((r) => queueMicrotask(() => r(undefined)))
+      // Should not throw or double-log
+      console.log = origLog
+    })
+
+    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)
+
+      const s = signal(0) // no name
+      why()
+      s.set(1)
+
+      await new Promise((r) => queueMicrotask(() => r(undefined)))
+
+      const anonLog = logs.find((args) =>
+        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", () => {
+      const groupCalls: unknown[][] = []
+      const logCalls: unknown[][] = []
+      const origGroup = console.group
+      const origLog = console.log
+      const origEnd = console.groupEnd
+      console.group = (...args: unknown[]) => groupCalls.push(args)
+      console.log = (...args: unknown[]) => logCalls.push(args)
+      console.groupEnd = () => {}
+
+      const s = signal(42, { name: "count" })
+      const info = inspectSignal(s)
+
+      expect(info.name).toBe("count")
+      expect(info.value).toBe(42)
+      expect(info.subscriberCount).toBe(0)
+      expect(groupCalls.length).toBe(1)
+      expect(logCalls.length).toBe(2) // value + subscribers
+
+      console.group = origGroup
+      console.log = origLog
+      console.groupEnd = origEnd
+    })
+
+    test("handles anonymous signal", () => {
+      const origGroup = console.group
+      const origLog = console.log
+      const origEnd = console.groupEnd
+      console.group = () => {}
+      console.log = () => {}
+      console.groupEnd = () => {}
+
+      const s = signal(0)
+      const info = inspectSignal(s)
+
+      expect(info.name).toBeUndefined()
+
+      console.group = origGroup
+      console.log = origLog
+      console.groupEnd = origEnd
+    })
+  })
+})