@pyreon/reactivity 0.1.0

package/src/tests/effect.test.ts

@@ -0,0 +1,256 @@
+import { effect, renderEffect, setErrorHandler } from "../effect"
+import { effectScope, setCurrentScope } from "../scope"
+import { signal } from "../signal"
+
+describe("effect", () => {
+  test("runs immediately", () => {
+    let ran = false
+    effect(() => {
+      ran = true
+    })
+    expect(ran).toBe(true)
+  })
+
+  test("re-runs when tracked signal changes", () => {
+    const s = signal(0)
+    let count = 0
+    effect(() => {
+      s() // track
+      count++
+    })
+    expect(count).toBe(1)
+    s.set(1)
+    expect(count).toBe(2)
+    s.set(2)
+    expect(count).toBe(3)
+  })
+
+  test("does not re-run after dispose", () => {
+    const s = signal(0)
+    let count = 0
+    const e = effect(() => {
+      s()
+      count++
+    })
+    e.dispose()
+    s.set(1)
+    expect(count).toBe(1) // only the initial run
+  })
+
+  test("tracks multiple signals", () => {
+    const a = signal(1)
+    const b = signal(2)
+    let result = 0
+    effect(() => {
+      result = a() + b()
+    })
+    expect(result).toBe(3)
+    a.set(10)
+    expect(result).toBe(12)
+    b.set(20)
+    expect(result).toBe(30)
+  })
+
+  test("does not track signals accessed after conditional branch", () => {
+    const toggle = signal(true)
+    const a = signal(1)
+    const b = signal(100)
+    let result = 0
+    effect(() => {
+      result = toggle() ? a() : b()
+    })
+    expect(result).toBe(1)
+    a.set(2)
+    expect(result).toBe(2)
+    toggle.set(false)
+    expect(result).toBe(100)
+    // a is no longer tracked
+    a.set(999)
+    expect(result).toBe(100)
+  })
+
+  test("catches errors via default error handler", () => {
+    const errors: unknown[] = []
+    const origError = console.error
+    console.error = (...args: unknown[]) => errors.push(args)
+
+    const s = signal(0)
+    effect(() => {
+      s()
+      throw new Error("boom")
+    })
+
+    expect(errors.length).toBe(1)
+    console.error = origError
+  })
+
+  test("calls cleanup before re-run", () => {
+    const s = signal(0)
+    let cleanups = 0
+    effect(() => {
+      s()
+      return () => {
+        cleanups++
+      }
+    })
+    expect(cleanups).toBe(0)
+    s.set(1) // re-run: previous cleanup fires
+    expect(cleanups).toBe(1)
+    s.set(2)
+    expect(cleanups).toBe(2)
+  })
+
+  test("calls cleanup on dispose", () => {
+    const s = signal(0)
+    let cleanups = 0
+    const e = effect(() => {
+      s()
+      return () => {
+        cleanups++
+      }
+    })
+    expect(cleanups).toBe(0)
+    e.dispose()
+    expect(cleanups).toBe(1)
+    // Disposing again should not call cleanup again
+    e.dispose()
+    expect(cleanups).toBe(1)
+  })
+
+  test("cleanup errors are caught by error handler", () => {
+    const caught: unknown[] = []
+    setErrorHandler((err) => caught.push(err))
+
+    const s = signal(0)
+    effect(() => {
+      s()
+      return () => {
+        throw new Error("cleanup boom")
+      }
+    })
+    s.set(1) // triggers cleanup which throws
+    expect(caught.length).toBe(1)
+    expect((caught[0] as Error).message).toBe("cleanup boom")
+
+    // Restore default handler
+    setErrorHandler((_err) => {})
+  })
+
+  test("works with no cleanup return (backwards compatible)", () => {
+    const s = signal(0)
+    let count = 0
+    effect(() => {
+      s()
+      count++
+      // no return
+    })
+    expect(count).toBe(1)
+    s.set(1)
+    expect(count).toBe(2)
+  })
+
+  test("setErrorHandler replaces the error handler", () => {
+    const caught: unknown[] = []
+    setErrorHandler((err) => caught.push(err))
+
+    const s = signal(0)
+    effect(() => {
+      s()
+      throw new Error("custom")
+    })
+
+    expect(caught.length).toBe(1)
+    expect((caught[0] as Error).message).toBe("custom")
+
+    // Restore default handler
+    setErrorHandler((_err) => {})
+  })
+
+  test("effect notifies scope on re-run (not first run)", async () => {
+    const scope = effectScope()
+    setCurrentScope(scope)
+
+    let updateCount = 0
+    scope.addUpdateHook(() => {
+      updateCount++
+    })
+
+    const s = signal(0)
+    effect(() => {
+      s()
+    })
+
+    setCurrentScope(null)
+
+    expect(updateCount).toBe(0) // first run does not notify
+
+    s.set(1) // re-run triggers notifyEffectRan
+    await new Promise((r) => setTimeout(r, 10))
+    expect(updateCount).toBe(1)
+
+    scope.stop()
+  })
+})
+
+describe("renderEffect", () => {
+  test("runs immediately and tracks signals", () => {
+    const s = signal(0)
+    let count = 0
+    renderEffect(() => {
+      s()
+      count++
+    })
+    expect(count).toBe(1)
+    s.set(1)
+    expect(count).toBe(2)
+  })
+
+  test("dispose stops tracking", () => {
+    const s = signal(0)
+    let count = 0
+    const dispose = renderEffect(() => {
+      s()
+      count++
+    })
+    expect(count).toBe(1)
+    dispose()
+    s.set(1)
+    expect(count).toBe(1)
+  })
+
+  test("dispose is idempotent", () => {
+    const s = signal(0)
+    const dispose = renderEffect(() => {
+      s()
+    })
+    dispose()
+    dispose() // should not throw
+  })
+
+  test("tracks dynamic dependencies", () => {
+    const toggle = signal(true)
+    const a = signal(1)
+    const b = signal(100)
+    let result = 0
+    renderEffect(() => {
+      result = toggle() ? a() : b()
+    })
+    expect(result).toBe(1)
+    toggle.set(false)
+    expect(result).toBe(100)
+    a.set(999) // no longer tracked
+    expect(result).toBe(100)
+  })
+
+  test("does not re-run after disposed during signal update", () => {
+    const s = signal(0)
+    let count = 0
+    const dispose = renderEffect(() => {
+      s()
+      count++
+    })
+    dispose()
+    s.set(5)
+    expect(count).toBe(1)
+  })
+})

package/src/tests/resource.test.ts

@@ -0,0 +1,133 @@
+import { createResource } from "../resource"
+import { signal } from "../signal"
+
+describe("createResource", () => {
+  test("fetches data when source changes", async () => {
+    const userId = signal(1)
+    const resource = createResource(
+      () => userId(),
+      (id) => Promise.resolve(`user-${id}`),
+    )
+
+    expect(resource.loading()).toBe(true)
+    expect(resource.data()).toBeUndefined()
+    expect(resource.error()).toBeUndefined()
+
+    await new Promise((r) => setTimeout(r, 10))
+
+    expect(resource.data()).toBe("user-1")
+    expect(resource.loading()).toBe(false)
+    expect(resource.error()).toBeUndefined()
+  })
+
+  test("re-fetches when source signal changes", async () => {
+    const userId = signal(1)
+    const resource = createResource(
+      () => userId(),
+      (id) => Promise.resolve(`user-${id}`),
+    )
+
+    await new Promise((r) => setTimeout(r, 10))
+    expect(resource.data()).toBe("user-1")
+
+    userId.set(2)
+    expect(resource.loading()).toBe(true)
+
+    await new Promise((r) => setTimeout(r, 10))
+    expect(resource.data()).toBe("user-2")
+    expect(resource.loading()).toBe(false)
+  })
+
+  test("handles fetcher errors", async () => {
+    const userId = signal(1)
+    const resource = createResource(
+      () => userId(),
+      (_id) => Promise.reject(new Error("network error")),
+    )
+
+    await new Promise((r) => setTimeout(r, 10))
+
+    expect(resource.error()).toBeInstanceOf(Error)
+    expect((resource.error() as Error).message).toBe("network error")
+    expect(resource.loading()).toBe(false)
+    expect(resource.data()).toBeUndefined()
+  })
+
+  test("refetch re-runs the fetcher with current source", async () => {
+    let fetchCount = 0
+    const userId = signal(1)
+    const resource = createResource(
+      () => userId(),
+      (id) => {
+        fetchCount++
+        return Promise.resolve(`user-${id}-${fetchCount}`)
+      },
+    )
+
+    await new Promise((r) => setTimeout(r, 10))
+    expect(resource.data()).toBe("user-1-1")
+
+    resource.refetch()
+    await new Promise((r) => setTimeout(r, 10))
+    expect(resource.data()).toBe("user-1-2")
+  })
+
+  test("ignores stale responses (race condition)", async () => {
+    const userId = signal(1)
+    const resolvers: ((v: string) => void)[] = []
+
+    const resource = createResource(
+      () => userId(),
+      (_id) =>
+        new Promise<string>((resolve) => {
+          resolvers.push((v) => resolve(v))
+        }),
+    )
+
+    // First fetch is in flight
+    expect(resolvers.length).toBe(1)
+
+    // Change source — triggers second fetch
+    userId.set(2)
+    expect(resolvers.length).toBe(2)
+
+    // Resolve the SECOND request first
+    resolvers[1]?.("user-2")
+    await new Promise((r) => setTimeout(r, 10))
+    expect(resource.data()).toBe("user-2")
+
+    // Now resolve the FIRST (stale) request — should be ignored
+    resolvers[0]?.("user-1")
+    await new Promise((r) => setTimeout(r, 10))
+    expect(resource.data()).toBe("user-2") // still user-2, not user-1
+  })
+
+  test("ignores stale errors (race condition)", async () => {
+    const userId = signal(1)
+    const rejecters: ((e: Error) => void)[] = []
+    const resolvers: ((v: string) => void)[] = []
+
+    const resource = createResource(
+      () => userId(),
+      (_id) =>
+        new Promise<string>((resolve, reject) => {
+          resolvers.push(resolve)
+          rejecters.push(reject)
+        }),
+    )
+
+    // First fetch in flight, change source
+    userId.set(2)
+
+    // Resolve second request
+    resolvers[1]?.("user-2")
+    await new Promise((r) => setTimeout(r, 10))
+    expect(resource.data()).toBe("user-2")
+
+    // Reject first (stale) request — should be ignored
+    rejecters[0]?.(new Error("stale error"))
+    await new Promise((r) => setTimeout(r, 10))
+    expect(resource.error()).toBeUndefined()
+    expect(resource.data()).toBe("user-2")
+  })
+})

package/src/tests/scope.test.ts

@@ -0,0 +1,202 @@
+import { effect } from "../effect"
+import { EffectScope, effectScope, getCurrentScope, setCurrentScope } from "../scope"
+import { signal } from "../signal"
+
+describe("effectScope", () => {
+  test("creates an EffectScope instance", () => {
+    const scope = effectScope()
+    expect(scope).toBeInstanceOf(EffectScope)
+  })
+
+  test("getCurrentScope returns null by default", () => {
+    expect(getCurrentScope()).toBeNull()
+  })
+
+  test("setCurrentScope sets and clears the current scope", () => {
+    const scope = effectScope()
+    setCurrentScope(scope)
+    expect(getCurrentScope()).toBe(scope)
+    setCurrentScope(null)
+    expect(getCurrentScope()).toBeNull()
+  })
+
+  test("effects created within a scope are disposed on stop", () => {
+    const scope = effectScope()
+    setCurrentScope(scope)
+
+    const s = signal(0)
+    let count = 0
+    effect(() => {
+      s()
+      count++
+    })
+
+    setCurrentScope(null)
+
+    expect(count).toBe(1)
+    s.set(1)
+    expect(count).toBe(2)
+
+    scope.stop()
+    s.set(2)
+    expect(count).toBe(2) // effect disposed, no re-run
+  })
+
+  test("stop is idempotent — second call does nothing", () => {
+    const scope = effectScope()
+    setCurrentScope(scope)
+
+    const s = signal(0)
+    let count = 0
+    effect(() => {
+      s()
+      count++
+    })
+
+    setCurrentScope(null)
+    scope.stop()
+    scope.stop() // should not throw
+    s.set(1)
+    expect(count).toBe(1)
+  })
+
+  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", () => {
+    const scope = effectScope()
+    setCurrentScope(null)
+
+    const s = signal(0)
+    let count = 0
+
+    scope.runInScope(() => {
+      effect(() => {
+        s()
+        count++
+      })
+    })
+
+    expect(getCurrentScope()).toBeNull() // restored
+    expect(count).toBe(1)
+    s.set(1)
+    expect(count).toBe(2)
+
+    scope.stop()
+    s.set(2)
+    expect(count).toBe(2) // disposed via scope
+  })
+
+  test("runInScope restores previous scope even on error", () => {
+    const scope = effectScope()
+    const prevScope = effectScope()
+    setCurrentScope(prevScope)
+
+    try {
+      scope.runInScope(() => {
+        expect(getCurrentScope()).toBe(scope)
+        throw new Error("test")
+      })
+    } catch {
+      // expected
+    }
+
+    expect(getCurrentScope()).toBe(prevScope)
+    setCurrentScope(null)
+  })
+
+  test("runInScope returns the function's return value", () => {
+    const scope = effectScope()
+    const result = scope.runInScope(() => 42)
+    expect(result).toBe(42)
+  })
+
+  test("addUpdateHook + notifyEffectRan fires hooks via microtask", async () => {
+    const scope = effectScope()
+    let hookCalled = 0
+
+    scope.addUpdateHook(() => {
+      hookCalled++
+    })
+
+    scope.notifyEffectRan()
+    expect(hookCalled).toBe(0) // not yet — microtask
+
+    await new Promise((r) => setTimeout(r, 10))
+    expect(hookCalled).toBe(1)
+  })
+
+  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 () => {
+    const scope = effectScope()
+    let hookCalled = 0
+
+    scope.addUpdateHook(() => {
+      hookCalled++
+    })
+
+    scope.stop()
+    scope.notifyEffectRan()
+
+    await new Promise((r) => setTimeout(r, 10))
+    expect(hookCalled).toBe(0)
+  })
+
+  test("notifyEffectRan deduplicates — only one microtask while pending", async () => {
+    const scope = effectScope()
+    let hookCalled = 0
+
+    scope.addUpdateHook(() => {
+      hookCalled++
+    })
+
+    scope.notifyEffectRan()
+    scope.notifyEffectRan()
+    scope.notifyEffectRan()
+
+    await new Promise((r) => setTimeout(r, 10))
+    expect(hookCalled).toBe(1) // only fired once
+  })
+
+  test("notifyEffectRan skips hooks if scope stopped before microtask fires", async () => {
+    const scope = effectScope()
+    let hookCalled = 0
+
+    scope.addUpdateHook(() => {
+      hookCalled++
+    })
+
+    scope.notifyEffectRan()
+    scope.stop() // stop before microtask runs
+
+    await new Promise((r) => setTimeout(r, 10))
+    expect(hookCalled).toBe(0)
+  })
+
+  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")
+    })
+
+    scope.notifyEffectRan()
+    await new Promise((r) => setTimeout(r, 10))
+
+    expect(errors.length).toBe(1)
+    console.error = origError
+  })
+})

package/src/tests/signal.test.ts

@@ -0,0 +1,120 @@
+import { effect } from "../effect"
+import { signal } from "../signal"
+
+describe("signal", () => {
+  test("reads initial value", () => {
+    const s = signal(42)
+    expect(s()).toBe(42)
+  })
+
+  test("set updates value", () => {
+    const s = signal(0)
+    s.set(10)
+    expect(s()).toBe(10)
+  })
+
+  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", () => {
+    const s = signal(1)
+    let calls = 0
+    effect(() => {
+      s() // track
+      calls++
+    })
+    expect(calls).toBe(1) // initial run
+    s.set(1) // same value — no notification
+    expect(calls).toBe(1)
+    s.set(2) // different value — notifies
+    expect(calls).toBe(2)
+  })
+
+  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", () => {
+    const s = signal<string | null>(null)
+    expect(s()).toBeNull()
+    s.set("hello")
+    expect(s()).toBe("hello")
+  })
+
+  test("peek reads value without tracking", () => {
+    const s = signal(42)
+    let count = 0
+    effect(() => {
+      s.peek() // should NOT track
+      count++
+    })
+    expect(count).toBe(1)
+    s.set(100)
+    expect(count).toBe(1) // no re-run because peek doesn't track
+    expect(s.peek()).toBe(100)
+  })
+
+  test("subscribe adds a static listener", () => {
+    const s = signal(0)
+    let notified = 0
+    const unsub = s.subscribe(() => {
+      notified++
+    })
+
+    s.set(1)
+    expect(notified).toBe(1)
+    s.set(2)
+    expect(notified).toBe(2)
+
+    unsub()
+    s.set(3)
+    expect(notified).toBe(2) // unsubscribed
+  })
+
+  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 setter updates the name", () => {
+    const s = signal(0)
+    expect(s.label).toBeUndefined()
+    s.label = "renamed"
+    expect(s.label).toBe("renamed")
+  })
+
+  test("debug() returns signal info", () => {
+    const s = signal(42, { name: "test" })
+    const info = s.debug()
+    expect(info.name).toBe("test")
+    expect(info.value).toBe(42)
+    expect(info.subscriberCount).toBe(0)
+  })
+
+  test("debug() reports subscriber count", () => {
+    const s = signal(0)
+    s.subscribe(() => {})
+    s.subscribe(() => {})
+    const info = s.debug()
+    expect(info.subscriberCount).toBe(2)
+  })
+
+  test("signal without options has undefined name", () => {
+    const s = signal(0)
+    expect(s.label).toBeUndefined()
+    const info = s.debug()
+    expect(info.name).toBeUndefined()
+  })
+})