@zeix/cause-effect 0.14.1 → 0.15.0

package/test/benchmark.test.ts

@@ -1,10 +1,7 @@
-import { describe, test, expect, mock } from 'bun:test'
-import { state, computed, effect, batch } from '../'
-import { makeGraph, runGraph, Counter } from './util/dependency-graph'
-import {
-	type ReactiveFramework,
-	type Computed,
-} from './util/reactive-framework'
+import { describe, expect, mock, test } from 'bun:test'
+import { batch, computed, effect, state } from '../'
+import { Counter, makeGraph, runGraph } from './util/dependency-graph'
+import type { Computed, ReactiveFramework } from './util/reactive-framework'
 
 /* === Utility Functions === */
 
@@ -30,8 +27,8 @@ const framework = {
 			read: () => c.get(),
 		}
 	},
-	effect: (fn: () => void) => effect(fn),
-	withBatch: (fn: () => void) => batch(fn),
+	effect: (fn: () => undefined) => effect(fn),
+	withBatch: (fn: () => undefined) => batch(fn),
 	withBuild: <T>(fn: () => T) => fn(),
 }
 const testPullCounts = true
@@ -53,7 +50,7 @@ function makeConfig() {
 /** some basic tests to validate the reactive framework
  * wrapper works and can run performance tests.
  */
-describe('Basic test', function () {
+describe('Basic test', () => {
 	const name = framework.name
 	test(`${name} | simple dependency executes`, () => {
 		framework.withBuild(() => {
@@ -145,11 +142,11 @@ describe('Basic test', function () {
 	})
 
 	test(`${name} | effect`, () => {
-		const spy = _v => {}
+		const spy = (_v: number) => {}
 		const spyMock = mock(spy)
 
 		const s = framework.signal(2)
-		let c: any
+		let c: { read: () => number } = { read: () => 0 }
 
 		framework.withBuild(() => {
 			c = framework.computed(() => s.read() * 2)
@@ -169,18 +166,22 @@ describe('Basic test', function () {
 	})
 })
 
-describe('Kairo tests', function () {
+describe('Kairo tests', () => {
 	const name = framework.name
 
-	test(`${name} | avoidable propagation`, () => {
+	test(`${name} | avoidable propagation`, async () => {
 		const head = framework.signal(0)
 		const computed1 = framework.computed(() => head.read())
-		const computed2 = framework.computed(() => (computed1.read(), 0))
-		const computed3 = framework.computed(
-			() => (busy(), computed2.read()! + 1),
-		) // heavy computation
-		const computed4 = framework.computed(() => computed3.read()! + 2)
-		const computed5 = framework.computed(() => computed4.read()! + 3)
+		const computed2 = framework.computed(() => {
+			computed1.read()
+			return 0
+		})
+		const computed3 = framework.computed(() => {
+			busy()
+			return computed2.read() + 1
+		}) // heavy computation
+		const computed4 = framework.computed(() => computed3.read() + 2)
+		const computed5 = framework.computed(() => computed4.read() + 3)
 		framework.effect(() => {
 			computed5.read()
 			busy() // heavy side effect
@@ -200,16 +201,16 @@ describe('Kairo tests', function () {
 		}
 	})
 
-	test(`${name} | broad propagation`, () => {
+	test(`${name} | broad propagation`, async () => {
 		const head = framework.signal(0)
 		let last = head as { read: () => number }
 		const callCounter = new Counter()
 		for (let i = 0; i < 50; i++) {
 			const current = framework.computed(() => {
-				return head.read()! + i
+				return head.read() + i
 			})
 			const current2 = framework.computed(() => {
-				return current.read()! + 1
+				return current.read() + 1
 			})
 			framework.effect(() => {
 				current2.read()
@@ -234,7 +235,7 @@ describe('Kairo tests', function () {
 		}
 	})
 
-	test(`${name} | deep propagation`, () => {
+	test(`${name} | deep propagation`, async () => {
 		const len = 50
 		const head = framework.signal(0)
 		let current = head as { read: () => number }
@@ -267,7 +268,7 @@ describe('Kairo tests', function () {
 		}
 	})
 
-	test(`${name} | diamond`, function () {
+	test(`${name} | diamond`, async () => {
 		const width = 5
 		const head = framework.signal(0)
 		const current: { read(): number }[] = []
@@ -300,7 +301,7 @@ describe('Kairo tests', function () {
 		}
 	})
 
-	test(`${name} | mux`, function () {
+	test(`${name} | mux`, async () => {
 		const heads = new Array(100).fill(null).map(_ => framework.signal(0))
 		const mux = framework.computed(() => {
 			return Object.fromEntries(heads.map(h => h.read()).entries())
@@ -310,7 +311,9 @@ describe('Kairo tests', function () {
 			.map(x => framework.computed(() => x.read() + 1))
 
 		splited.forEach(x => {
-			framework.effect(() => x.read())
+			framework.effect(() => {
+				x.read()
+			})
 		})
 
 		return () => {
@@ -329,7 +332,7 @@ describe('Kairo tests', function () {
 		}
 	})
 
-	test(`${name} | repeated observers`, function () {
+	test(`${name} | repeated observers`, async () => {
 		const size = 30
 		const head = framework.signal(0)
 		const current = framework.computed(() => {
@@ -362,7 +365,7 @@ describe('Kairo tests', function () {
 		}
 	})
 
-	test(`${name} | triangle`, function () {
+	test(`${name} | triangle`, async () => {
 		const width = 10
 		const head = framework.signal(0)
 		let current = head as { read: () => number }
@@ -407,7 +410,7 @@ describe('Kairo tests', function () {
 		}
 	})
 
-	test(`${name} | unstable`, function () {
+	test(`${name} | unstable`, async () => {
 		const head = framework.signal(0)
 		const double = framework.computed(() => head.read() * 2)
 		const inverse = framework.computed(() => -head.read())
@@ -442,10 +445,10 @@ describe('Kairo tests', function () {
 	})
 })
 
-describe('$mol_wire tests', function () {
+describe('$mol_wire tests', () => {
 	const name = framework.name
 
-	test(`${name} | $mol_wire benchmark`, function () {
+	test(`${name} | $mol_wire benchmark`, () => {
 		const fib = (n: number) => {
 			if (n < 2) return 1
 			return fib(n - 1) + fib(n - 2)
@@ -454,7 +457,7 @@ describe('$mol_wire tests', function () {
 			return n + fib(16)
 		}
 		const numbers = Array.from({ length: 5 }, (_, i) => i)
-		const res: (() => any)[] = []
+		const res: (() => unknown)[] = []
 		framework.withBuild(() => {
 			const A = framework.signal(0)
 			const B = framework.signal(0)
@@ -475,12 +478,24 @@ describe('$mol_wire tests', function () {
 					D.read()[4].x +
 					F.read(),
 			)
-			framework.effect(() => res.push(hard(G.read(), 'H')))
-			framework.effect(() => res.push(G.read())) // I
-			framework.effect(() => res.push(hard(F.read(), 'J')))
-			framework.effect(() => (res[0] = hard(G.read(), 'H')))
-			framework.effect(() => (res[1] = G.read())) // I
-			framework.effect(() => (res[2] = hard(F.read(), 'J')))
+			framework.effect(() => {
+				res.push(hard(G.read(), 'H'))
+			})
+			framework.effect(() => {
+				res.push(G.read())
+			}) // I
+			framework.effect(() => {
+				res.push(hard(F.read(), 'J'))
+			})
+			framework.effect(() => {
+				res[0] = hard(G.read(), 'H')
+			})
+			framework.effect(() => {
+				res[1] = G.read()
+			}) // I
+			framework.effect(() => {
+				res[2] = hard(F.read(), 'J')
+			})
 
 			return (i: number) => {
 				res.length = 0
@@ -499,10 +514,10 @@ describe('$mol_wire tests', function () {
 	})
 })
 
-describe('CellX tests', function () {
+describe('CellX tests', () => {
 	const name = framework.name
 
-	test(`${name} | CellX benchmark`, function () {
+	test(`${name} | CellX benchmark`, () => {
 		const expected = {
 			10: [
 				[3, 6, 2, -2],
@@ -540,10 +555,31 @@ describe('CellX tests', function () {
 					prop4: framework.computed(() => m.prop3.read()),
 				}
 
-				framework.effect(() => s.prop1.read())
-				framework.effect(() => s.prop2.read())
-				framework.effect(() => s.prop3.read())
-				framework.effect(() => s.prop4.read())
+				framework.effect(() => {
+					s.prop1.read()
+				})
+				framework.effect(() => {
+					s.prop2.read()
+				})
+				framework.effect(() => {
+					s.prop3.read()
+				})
+				framework.effect(() => {
+					s.prop4.read()
+				})
+
+				framework.effect(() => {
+					s.prop1.read()
+				})
+				framework.effect(() => {
+					s.prop2.read()
+				})
+				framework.effect(() => {
+					s.prop3.read()
+				})
+				framework.effect(() => {
+					s.prop4.read()
+				})
 
 				s.prop1.read()
 				s.prop2.read()

package/test/computed.test.ts

@@ -1,12 +1,14 @@
-import { describe, test, expect } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import {
-	state,
 	computed,
-	UNSET,
+	effect,
 	isComputed,
 	isState,
-	effect,
-} from '../index.ts'
+	match,
+	resolve,
+	state,
+	UNSET,
+} from '../'
 
 /* === Utility Functions === */
 
@@ -15,7 +17,7 @@ const increment = (n: number) => (Number.isFinite(n) ? n + 1 : UNSET)
 
 /* === Tests === */
 
-describe('Computed', function () {
+describe('Computed', () => {
 	test('should identify computed signals with isComputed()', () => {
 		const count = state(42)
 		const doubled = computed(() => count.get() * 2)
@@ -23,25 +25,25 @@ describe('Computed', function () {
 		expect(isState(doubled)).toBe(false)
 	})
 
-	test('should compute a function', function () {
+	test('should compute a function', () => {
 		const derived = computed(() => 1 + 2)
 		expect(derived.get()).toBe(3)
 	})
 
-	test('should compute function dependent on a signal', function () {
+	test('should compute function dependent on a signal', () => {
 		const cause = state(42)
 		const derived = computed(() => cause.get() + 1)
 		expect(derived.get()).toBe(43)
 	})
 
-	test('should compute function dependent on an updated signal', function () {
+	test('should compute function dependent on an updated signal', () => {
 		const cause = state(42)
 		const derived = computed(() => cause.get() + 1)
 		cause.set(24)
 		expect(derived.get()).toBe(25)
 	})
 
-	test('should compute function dependent on an async signal', async function () {
+	test('should compute function dependent on an async signal', async () => {
 		const status = state('pending')
 		const promised = computed(async () => {
 			await wait(100)
@@ -56,7 +58,7 @@ describe('Computed', function () {
 		expect(status.get()).toBe('success')
 	})
 
-	test('should handle errors from an async signal gracefully', async function () {
+	test('should handle errors from an async signal gracefully', async () => {
 		const status = state('pending')
 		const error = state('')
 		const promised = computed(async () => {
@@ -73,7 +75,7 @@ describe('Computed', function () {
 		expect(status.get()).toBe('error')
 	})
 
-	test('should compute task signals in parallel without waterfalls', async function () {
+	test('should compute task signals in parallel without waterfalls', async () => {
 		const a = computed(async () => {
 			await wait(100)
 			return 10
@@ -94,7 +96,7 @@ describe('Computed', function () {
 		expect(c.get()).toBe(30)
 	})
 
-	test('should compute function dependent on a chain of computed states dependent on a signal', function () {
+	test('should compute function dependent on a chain of computed states dependent on a signal', () => {
 		const x = state(42)
 		const a = computed(() => x.get() + 1)
 		const b = computed(() => a.get() * 2)
@@ -102,7 +104,7 @@ describe('Computed', function () {
 		expect(c.get()).toBe(87)
 	})
 
-	test('should compute function dependent on a chain of computed states dependent on an updated signal', function () {
+	test('should compute function dependent on a chain of computed states dependent on an updated signal', () => {
 		const x = state(42)
 		const a = computed(() => x.get() + 1)
 		const b = computed(() => a.get() * 2)
@@ -111,14 +113,14 @@ describe('Computed', function () {
 		expect(c.get()).toBe(51)
 	})
 
-	test('should drop X->B->X updates', function () {
+	test('should drop X->B->X updates', () => {
 		let count = 0
 		const x = state(2)
 		const a = computed(() => x.get() - 1)
 		const b = computed(() => x.get() + a.get())
 		const c = computed(() => {
 			count++
-			return 'c: ' + b.get()
+			return `c: ${b.get()}`
 		})
 		expect(c.get()).toBe('c: 3')
 		expect(count).toBe(1)
@@ -127,14 +129,14 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should only update every signal once (diamond graph)', function () {
+	test('should only update every signal once (diamond graph)', () => {
 		let count = 0
 		const x = state('a')
 		const a = computed(() => x.get())
 		const b = computed(() => x.get())
 		const c = computed(() => {
 			count++
-			return a.get() + ' ' + b.get()
+			return `${a.get()} ${b.get()}`
 		})
 		expect(c.get()).toBe('a a')
 		expect(count).toBe(1)
@@ -144,12 +146,12 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should only update every signal once (diamond graph + tail)', function () {
+	test('should only update every signal once (diamond graph + tail)', () => {
 		let count = 0
 		const x = state('a')
 		const a = computed(() => x.get())
 		const b = computed(() => x.get())
-		const c = computed(() => a.get() + ' ' + b.get())
+		const c = computed(() => `${a.get()} ${b.get()}`)
 		const d = computed(() => {
 			count++
 			return c.get()
@@ -161,7 +163,7 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should update multiple times after multiple state changes', function () {
+	test('should update multiple times after multiple state changes', () => {
 		const a = state(3)
 		const b = state(4)
 		let count = 0
@@ -185,7 +187,7 @@ describe('Computed', function () {
 	 * one-time performance cost that allows for efficient memoization and
 	 * error handling in most cases.
 	 */
-	test('should bail out if result is the same', function () {
+	test('should bail out if result is the same', () => {
 		let count = 0
 		const x = state('a')
 		const a = computed(() => {
@@ -205,7 +207,7 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should block if result remains unchanged', function () {
+	test('should block if result remains unchanged', () => {
 		let count = 0
 		const x = state(42)
 		const a = computed(() => x.get() % 2)
@@ -223,7 +225,7 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should detect and throw error for circular dependencies', function () {
+	test('should detect and throw error for circular dependencies', () => {
 		const a = state(1)
 		const b = computed(() => c.get() + 1)
 		const c = computed(() => b.get() + a.get())
@@ -233,7 +235,7 @@ describe('Computed', function () {
 		expect(a.get()).toBe(1)
 	})
 
-	test('should propagate error if an error occurred', function () {
+	test('should propagate error if an error occurred', () => {
 		let okCount = 0
 		let errCount = 0
 		const x = state(0)
@@ -273,7 +275,7 @@ describe('Computed', function () {
 		}
 	})
 
-	test('should create an effect that reacts on async computed changes', async function () {
+	test('should create an effect that reacts on async computed changes', async () => {
 		const cause = state(42)
 		const derived = computed(async () => {
 			await wait(100)
@@ -282,15 +284,17 @@ describe('Computed', function () {
 		let okCount = 0
 		let nilCount = 0
 		let result: number = 0
-		effect({
-			signals: [derived],
-			ok: v => {
-				result = v
-				okCount++
-			},
-			nil: () => {
-				nilCount++
-			},
+		effect(() => {
+			const resolved = resolve({ derived })
+			match(resolved, {
+				ok: ({ derived: v }) => {
+					result = v
+					okCount++
+				},
+				nil: () => {
+					nilCount++
+				},
+			})
 		})
 		cause.set(43)
 		expect(okCount).toBe(0)
@@ -303,7 +307,7 @@ describe('Computed', function () {
 		expect(result).toBe(44)
 	})
 
-	test('should handle complex computed signal with error and async dependencies', async function () {
+	test('should handle complex computed signal with error and async dependencies', async () => {
 		const toggleState = state(true)
 		const errorProne = computed(() => {
 			if (toggleState.get()) throw new Error('Intentional error')
@@ -350,7 +354,7 @@ describe('Computed', function () {
 		expect(errCount).toBeGreaterThan(0)
 	})
 
-	test('should handle signal changes during async computation', async function () {
+	test('should handle signal changes during async computation', async () => {
 		const source = state(1)
 		let computationCount = 0
 		const derived = computed(async abort => {
@@ -371,7 +375,7 @@ describe('Computed', function () {
 		expect(computationCount).toBe(1)
 	})
 
-	test('should handle multiple rapid changes during async computation', async function () {
+	test('should handle multiple rapid changes during async computation', async () => {
 		const source = state(1)
 		let computationCount = 0
 		const derived = computed(async abort => {
@@ -396,7 +400,7 @@ describe('Computed', function () {
 		expect(computationCount).toBe(1)
 	})
 
-	test('should handle errors in aborted computations', async function () {
+	test('should handle errors in aborted computations', async () => {
 		const source = state(1)
 		const derived = computed(async () => {
 			await wait(100)