@pyreon/reactivity 0.11.4 → 0.11.6

package/src/tests/effect.test.ts

@@ -1,9 +1,9 @@
-import { effect, onCleanup, renderEffect, setErrorHandler } from "../effect"
-import { effectScope, setCurrentScope } from "../scope"
-import { signal } from "../signal"
+import { effect, onCleanup, renderEffect, setErrorHandler } from '../effect'
+import { effectScope, setCurrentScope } from '../scope'
+import { signal } from '../signal'
 
-describe("effect", () => {
-  test("runs immediately", () => {
+describe('effect', () => {
+  test('runs immediately', () => {
     let ran = false
     effect(() => {
       ran = true
@@ -11,7 +11,7 @@ describe("effect", () => {
     expect(ran).toBe(true)
   })
 
-  test("re-runs when tracked signal changes", () => {
+  test('re-runs when tracked signal changes', () => {
     const s = signal(0)
     let count = 0
     effect(() => {
@@ -25,7 +25,7 @@ describe("effect", () => {
     expect(count).toBe(3)
   })
 
-  test("does not re-run after dispose", () => {
+  test('does not re-run after dispose', () => {
     const s = signal(0)
     let count = 0
     const e = effect(() => {
@@ -37,7 +37,7 @@ describe("effect", () => {
     expect(count).toBe(1) // only the initial run
   })
 
-  test("tracks multiple signals", () => {
+  test('tracks multiple signals', () => {
     const a = signal(1)
     const b = signal(2)
     let result = 0
@@ -51,7 +51,7 @@ describe("effect", () => {
     expect(result).toBe(30)
   })
 
-  test("does not track signals accessed after conditional branch", () => {
+  test('does not track signals accessed after conditional branch', () => {
     const toggle = signal(true)
     const a = signal(1)
     const b = signal(100)
@@ -69,7 +69,7 @@ describe("effect", () => {
     expect(result).toBe(100)
   })
 
-  test("catches errors via default error handler", () => {
+  test('catches errors via default error handler', () => {
     const errors: unknown[] = []
     const origError = console.error
     console.error = (...args: unknown[]) => errors.push(args)
@@ -77,14 +77,14 @@ describe("effect", () => {
     const s = signal(0)
     effect(() => {
       s()
-      throw new Error("boom")
+      throw new Error('boom')
     })
 
     expect(errors.length).toBe(1)
     console.error = origError
   })
 
-  test("calls cleanup before re-run", () => {
+  test('calls cleanup before re-run', () => {
     const s = signal(0)
     let cleanups = 0
     effect(() => {
@@ -100,7 +100,7 @@ describe("effect", () => {
     expect(cleanups).toBe(2)
   })
 
-  test("calls cleanup on dispose", () => {
+  test('calls cleanup on dispose', () => {
     const s = signal(0)
     let cleanups = 0
     const e = effect(() => {
@@ -117,7 +117,7 @@ describe("effect", () => {
     expect(cleanups).toBe(1)
   })
 
-  test("cleanup errors are caught by error handler", () => {
+  test('cleanup errors are caught by error handler', () => {
     const caught: unknown[] = []
     setErrorHandler((err) => caught.push(err))
 
@@ -125,18 +125,18 @@ describe("effect", () => {
     effect(() => {
       s()
       return () => {
-        throw new Error("cleanup boom")
+        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")
+    expect((caught[0] as Error).message).toBe('cleanup boom')
 
     // Restore default handler
     setErrorHandler((_err) => {})
   })
 
-  test("works with no cleanup return (backwards compatible)", () => {
+  test('works with no cleanup return (backwards compatible)', () => {
     const s = signal(0)
     let count = 0
     effect(() => {
@@ -149,24 +149,24 @@ describe("effect", () => {
     expect(count).toBe(2)
   })
 
-  test("setErrorHandler replaces the error handler", () => {
+  test('setErrorHandler replaces the error handler', () => {
     const caught: unknown[] = []
     setErrorHandler((err) => caught.push(err))
 
     const s = signal(0)
     effect(() => {
       s()
-      throw new Error("custom")
+      throw new Error('custom')
     })
 
     expect(caught.length).toBe(1)
-    expect((caught[0] as Error).message).toBe("custom")
+    expect((caught[0] as Error).message).toBe('custom')
 
     // Restore default handler
     setErrorHandler((_err) => {})
   })
 
-  test("effect notifies scope on re-run (not first run)", async () => {
+  test('effect notifies scope on re-run (not first run)', async () => {
     const scope = effectScope()
     setCurrentScope(scope)
 
@@ -192,8 +192,8 @@ describe("effect", () => {
   })
 })
 
-describe("renderEffect", () => {
-  test("runs immediately and tracks signals", () => {
+describe('renderEffect', () => {
+  test('runs immediately and tracks signals', () => {
     const s = signal(0)
     let count = 0
     renderEffect(() => {
@@ -205,7 +205,7 @@ describe("renderEffect", () => {
     expect(count).toBe(2)
   })
 
-  test("dispose stops tracking", () => {
+  test('dispose stops tracking', () => {
     const s = signal(0)
     let count = 0
     const dispose = renderEffect(() => {
@@ -218,7 +218,7 @@ describe("renderEffect", () => {
     expect(count).toBe(1)
   })
 
-  test("dispose is idempotent", () => {
+  test('dispose is idempotent', () => {
     const s = signal(0)
     const dispose = renderEffect(() => {
       s()
@@ -227,7 +227,7 @@ describe("renderEffect", () => {
     dispose() // should not throw
   })
 
-  test("tracks dynamic dependencies", () => {
+  test('tracks dynamic dependencies', () => {
     const toggle = signal(true)
     const a = signal(1)
     const b = signal(100)
@@ -242,7 +242,7 @@ describe("renderEffect", () => {
     expect(result).toBe(100)
   })
 
-  test("does not re-run after disposed during signal update", () => {
+  test('does not re-run after disposed during signal update', () => {
     const s = signal(0)
     let count = 0
     const dispose = renderEffect(() => {
@@ -255,8 +255,8 @@ describe("renderEffect", () => {
   })
 })
 
-describe("onCleanup", () => {
-  test("runs cleanup before effect re-runs", () => {
+describe('onCleanup', () => {
+  test('runs cleanup before effect re-runs', () => {
     const s = signal(0)
     const log: string[] = []
     effect(() => {
@@ -264,14 +264,14 @@ describe("onCleanup", () => {
       onCleanup(() => log.push(`cleanup-${val}`))
       log.push(`run-${val}`)
     })
-    expect(log).toEqual(["run-0"])
+    expect(log).toEqual(['run-0'])
     s.set(1)
-    expect(log).toEqual(["run-0", "cleanup-0", "run-1"])
+    expect(log).toEqual(['run-0', 'cleanup-0', 'run-1'])
     s.set(2)
-    expect(log).toEqual(["run-0", "cleanup-0", "run-1", "cleanup-1", "run-2"])
+    expect(log).toEqual(['run-0', 'cleanup-0', 'run-1', 'cleanup-1', 'run-2'])
   })
 
-  test("runs cleanup on dispose", () => {
+  test('runs cleanup on dispose', () => {
     let cleaned = false
     const e = effect(() => {
       onCleanup(() => {
@@ -283,36 +283,36 @@ describe("onCleanup", () => {
     expect(cleaned).toBe(true)
   })
 
-  test("supports multiple onCleanup calls", () => {
+  test('supports multiple onCleanup calls', () => {
     const s = signal(0)
     const log: string[] = []
     effect(() => {
       s()
-      onCleanup(() => log.push("a"))
-      onCleanup(() => log.push("b"))
+      onCleanup(() => log.push('a'))
+      onCleanup(() => log.push('b'))
     })
     s.set(1)
-    expect(log).toEqual(["a", "b"])
+    expect(log).toEqual(['a', 'b'])
   })
 
-  test("works alongside return cleanup", () => {
+  test('works alongside return cleanup', () => {
     const s = signal(0)
     const log: string[] = []
     effect(() => {
       s()
-      onCleanup(() => log.push("onCleanup"))
-      return () => log.push("return")
+      onCleanup(() => log.push('onCleanup'))
+      return () => log.push('return')
     })
     s.set(1)
-    expect(log).toEqual(["onCleanup", "return"])
+    expect(log).toEqual(['onCleanup', 'return'])
   })
 
-  test("no-ops outside effect", () => {
+  test('no-ops outside effect', () => {
     // Should not throw
     onCleanup(() => {})
   })
 
-  test("cleanup ordering: onCleanup runs before return cleanup", () => {
+  test('cleanup ordering: onCleanup runs before return cleanup', () => {
     const s = signal(0)
     const log: string[] = []
     effect(() => {
@@ -322,37 +322,37 @@ describe("onCleanup", () => {
     })
     s.set(1)
     // onCleanup should fire first, then return cleanup
-    expect(log).toEqual(["onCleanup-0", "return-0"])
+    expect(log).toEqual(['onCleanup-0', 'return-0'])
     s.set(2)
-    expect(log).toEqual(["onCleanup-0", "return-0", "onCleanup-1", "return-1"])
+    expect(log).toEqual(['onCleanup-0', 'return-0', 'onCleanup-1', 'return-1'])
   })
 
-  test("multiple onCleanup callbacks run in registration order", () => {
+  test('multiple onCleanup callbacks run in registration order', () => {
     const s = signal(0)
     const log: string[] = []
     effect(() => {
       s()
-      onCleanup(() => log.push("first"))
-      onCleanup(() => log.push("second"))
-      onCleanup(() => log.push("third"))
+      onCleanup(() => log.push('first'))
+      onCleanup(() => log.push('second'))
+      onCleanup(() => log.push('third'))
     })
     s.set(1)
-    expect(log).toEqual(["first", "second", "third"])
+    expect(log).toEqual(['first', 'second', 'third'])
   })
 
-  test("cleanup runs on dispose even when effect never re-ran", () => {
+  test('cleanup runs on dispose even when effect never re-ran', () => {
     const log: string[] = []
     const e = effect(() => {
-      onCleanup(() => log.push("disposed"))
+      onCleanup(() => log.push('disposed'))
     })
     expect(log).toEqual([])
     e.dispose()
-    expect(log).toEqual(["disposed"])
+    expect(log).toEqual(['disposed'])
   })
 })
 
-describe("effect — error handling", () => {
-  test("error in effect does not prevent other effects from running", () => {
+describe('effect — error handling', () => {
+  test('error in effect does not prevent other effects from running', () => {
     const caught: unknown[] = []
     setErrorHandler((err) => caught.push(err))
 
@@ -361,7 +361,7 @@ describe("effect — error handling", () => {
 
     effect(() => {
       s()
-      throw new Error("bad effect")
+      throw new Error('bad effect')
     })
     effect(() => {
       s()
@@ -378,7 +378,7 @@ describe("effect — error handling", () => {
     setErrorHandler((_err) => {})
   })
 
-  test("error during cleanup is caught by error handler", () => {
+  test('error during cleanup is caught by error handler', () => {
     const caught: unknown[] = []
     setErrorHandler((err) => caught.push(err))
 
@@ -386,13 +386,13 @@ describe("effect — error handling", () => {
     effect(() => {
       s()
       onCleanup(() => {
-        throw new Error("cleanup error")
+        throw new Error('cleanup error')
       })
     })
 
     s.set(1) // triggers cleanup which throws
     expect(caught).toHaveLength(1)
-    expect((caught[0] as Error).message).toBe("cleanup error")
+    expect((caught[0] as Error).message).toBe('cleanup error')
 
     setErrorHandler((_err) => {})
   })

package/src/tests/resource.test.ts

@@ -1,8 +1,8 @@
-import { createResource } from "../resource"
-import { signal } from "../signal"
+import { createResource } from '../resource'
+import { signal } from '../signal'
 
-describe("createResource", () => {
-  test("fetches data when source changes", async () => {
+describe('createResource', () => {
+  test('fetches data when source changes', async () => {
     const userId = signal(1)
     const resource = createResource(
       () => userId(),
@@ -15,12 +15,12 @@ describe("createResource", () => {
 
     await new Promise((r) => setTimeout(r, 10))
 
-    expect(resource.data()).toBe("user-1")
+    expect(resource.data()).toBe('user-1')
     expect(resource.loading()).toBe(false)
     expect(resource.error()).toBeUndefined()
   })
 
-  test("re-fetches when source signal changes", async () => {
+  test('re-fetches when source signal changes', async () => {
     const userId = signal(1)
     const resource = createResource(
       () => userId(),
@@ -28,32 +28,32 @@ describe("createResource", () => {
     )
 
     await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe("user-1")
+    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.data()).toBe('user-2')
     expect(resource.loading()).toBe(false)
   })
 
-  test("handles fetcher errors", async () => {
+  test('handles fetcher errors', async () => {
     const userId = signal(1)
     const resource = createResource(
       () => userId(),
-      (_id) => Promise.reject(new Error("network error")),
+      (_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.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 () => {
+  test('refetch re-runs the fetcher with current source', async () => {
     let fetchCount = 0
     const userId = signal(1)
     const resource = createResource(
@@ -65,14 +65,14 @@ describe("createResource", () => {
     )
 
     await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe("user-1-1")
+    expect(resource.data()).toBe('user-1-1')
 
     resource.refetch()
     await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe("user-1-2")
+    expect(resource.data()).toBe('user-1-2')
   })
 
-  test("ignores stale responses (race condition)", async () => {
+  test('ignores stale responses (race condition)', async () => {
     const userId = signal(1)
     const resolvers: ((v: string) => void)[] = []
 
@@ -92,17 +92,17 @@ describe("createResource", () => {
     expect(resolvers.length).toBe(2)
 
     // Resolve the SECOND request first
-    resolvers[1]?.("user-2")
+    resolvers[1]?.('user-2')
     await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe("user-2")
+    expect(resource.data()).toBe('user-2')
 
     // Now resolve the FIRST (stale) request — should be ignored
-    resolvers[0]?.("user-1")
+    resolvers[0]?.('user-1')
     await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe("user-2") // still user-2, not user-1
+    expect(resource.data()).toBe('user-2') // still user-2, not user-1
   })
 
-  test("ignores stale errors (race condition)", async () => {
+  test('ignores stale errors (race condition)', async () => {
     const userId = signal(1)
     const rejecters: ((e: Error) => void)[] = []
     const resolvers: ((v: string) => void)[] = []
@@ -120,18 +120,18 @@ describe("createResource", () => {
     userId.set(2)
 
     // Resolve second request
-    resolvers[1]?.("user-2")
+    resolvers[1]?.('user-2')
     await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe("user-2")
+    expect(resource.data()).toBe('user-2')
 
     // Reject first (stale) request — should be ignored
-    rejecters[0]?.(new Error("stale error"))
+    rejecters[0]?.(new Error('stale error'))
     await new Promise((r) => setTimeout(r, 10))
     expect(resource.error()).toBeUndefined()
-    expect(resource.data()).toBe("user-2")
+    expect(resource.data()).toBe('user-2')
   })
 
-  test("loading returns to true on refetch", async () => {
+  test('loading returns to true on refetch', async () => {
     const userId = signal(1)
     const resource = createResource(
       () => userId(),
@@ -140,7 +140,7 @@ describe("createResource", () => {
 
     await new Promise((r) => setTimeout(r, 10))
     expect(resource.loading()).toBe(false)
-    expect(resource.data()).toBe("user-1")
+    expect(resource.data()).toBe('user-1')
 
     resource.refetch()
     expect(resource.loading()).toBe(true)
@@ -149,12 +149,12 @@ describe("createResource", () => {
     expect(resource.loading()).toBe(false)
   })
 
-  test("error is cleared on successful refetch", async () => {
+  test('error is cleared on successful refetch', async () => {
     let shouldFail = true
     const src = signal(1)
     const resource = createResource(
       () => src(),
-      (_id) => (shouldFail ? Promise.reject(new Error("fail")) : Promise.resolve("ok")),
+      (_id) => (shouldFail ? Promise.reject(new Error('fail')) : Promise.resolve('ok')),
     )
 
     await new Promise((r) => setTimeout(r, 10))
@@ -164,18 +164,18 @@ describe("createResource", () => {
     resource.refetch()
     await new Promise((r) => setTimeout(r, 10))
     expect(resource.error()).toBeUndefined()
-    expect(resource.data()).toBe("ok")
+    expect(resource.data()).toBe('ok')
   })
 
-  test("error is cleared before each fetch attempt", async () => {
+  test('error is cleared before each fetch attempt', async () => {
     let callCount = 0
     const src = signal(1)
     const resource = createResource(
       () => src(),
       (_id) => {
         callCount++
-        if (callCount === 1) return Promise.reject(new Error("first fail"))
-        return Promise.resolve("success")
+        if (callCount === 1) return Promise.reject(new Error('first fail'))
+        return Promise.resolve('success')
       },
     )
 
@@ -189,14 +189,14 @@ describe("createResource", () => {
     expect(resource.loading()).toBe(true)
 
     await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe("success")
+    expect(resource.data()).toBe('success')
   })
 
-  test("data is undefined initially and after error", async () => {
+  test('data is undefined initially and after error', async () => {
     const src = signal(1)
     const resource = createResource(
       () => src(),
-      (_id) => Promise.reject(new Error("always fails")),
+      (_id) => Promise.reject(new Error('always fails')),
     )
 
     expect(resource.data()).toBeUndefined()
@@ -206,7 +206,7 @@ describe("createResource", () => {
     expect(resource.error()).toBeInstanceOf(Error)
   })
 
-  test("refetch uses current source value", async () => {
+  test('refetch uses current source value', async () => {
     const src = signal(1)
     const results: string[] = []
     const resource = createResource(
@@ -219,15 +219,15 @@ describe("createResource", () => {
     )
 
     await new Promise((r) => setTimeout(r, 10))
-    expect(results).toEqual(["user-1"])
+    expect(results).toEqual(['user-1'])
 
     src.set(5)
     await new Promise((r) => setTimeout(r, 10))
-    expect(results).toEqual(["user-1", "user-5"])
+    expect(results).toEqual(['user-1', 'user-5'])
 
     // Refetch should use current source value (5)
     resource.refetch()
     await new Promise((r) => setTimeout(r, 10))
-    expect(results).toEqual(["user-1", "user-5", "user-5"])
+    expect(results).toEqual(['user-1', 'user-5', 'user-5'])
   })
 })