@zeix/cause-effect 0.14.1 → 0.14.2

package/src/signal.ts

@@ -1,10 +1,10 @@
-import { isState, state } from './state'
 import {
 	type ComputedCallback,
+	computed,
 	isComputed,
 	isComputedCallback,
-	computed,
 } from './computed'
+import { isState, state } from './state'
 
 /* === Types === */
 
@@ -13,12 +13,13 @@ type Signal<T extends {}> = {
 }
 type MaybeSignal<T extends {}> = T | Signal<T> | ComputedCallback<T>
 
-type SignalValues<S extends Signal<{}>[]> = {
+type SignalValues<S extends Signal<unknown & {}>[]> = {
 	[K in keyof S]: S[K] extends Signal<infer T> ? T : never
 }
 
 /* === Constants === */
 
+// biome-ignore lint/suspicious/noExplicitAny: Deliberately using any to be used as a placeholder value in any signal
 const UNSET: any = Symbol()
 
 /* === Functions === */

package/src/util.ts

@@ -15,7 +15,7 @@ const toError = (reason: unknown): Error =>
 class CircularDependencyError extends Error {
 	constructor(where: string) {
 		super(`Circular dependency in ${where} detected`)
-		return this
+		this.name = 'CircularDependencyError'
 	}
 }
 

package/test/batch.test.ts

@@ -1,14 +1,14 @@
-import { describe, test, expect } from 'bun:test'
-import { state, computed, batch, effect } from '../'
+import { describe, expect, test } from 'bun:test'
+import { batch, computed, effect, state } from '../'
 
 /* === Tests === */
 
-describe('Batch', function () {
-	test('should be triggered only once after repeated state change', function () {
+describe('Batch', () => {
+	test('should be triggered only once after repeated state change', () => {
 		const cause = state(0)
 		let result = 0
 		let count = 0
-		effect(() => {
+		effect((): undefined => {
 			result = cause.get()
 			count++
 		})
@@ -21,7 +21,7 @@ describe('Batch', function () {
 		expect(count).toBe(2) // + 1 for effect initialization
 	})
 
-	test('should be triggered only once when multiple signals are set', function () {
+	test('should be triggered only once when multiple signals are set', () => {
 		const a = state(3)
 		const b = state(4)
 		const c = state(5)
@@ -30,11 +30,11 @@ describe('Batch', function () {
 		let count = 0
 		effect({
 			signals: [sum],
-			ok: res => {
+			ok: (res): undefined => {
 				result = res
 				count++
 			},
-			err: () => {},
+			err: (): undefined => {},
 		})
 		batch(() => {
 			a.set(6)
@@ -45,7 +45,7 @@ describe('Batch', function () {
 		expect(count).toBe(2) // + 1 for effect initialization
 	})
 
-	test('should prove example from README works', function () {
+	test('should prove example from README works', () => {
 		// State: define an array of Signal<number>
 		const signals = [state(2), state(3), state(5)]
 
@@ -63,12 +63,12 @@ describe('Batch', function () {
 		// Effect: switch cases for the result
 		effect({
 			signals: [sum],
-			ok: v => {
+			ok: (v): undefined => {
 				result = v
 				okCount++
 				// console.log('Sum:', v)
 			},
-			err: _error => {
+			err: (_error): undefined => {
 				errCount++
 				// console.error('Error:', error)
 			},

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`, () => {
 		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
@@ -206,10 +207,10 @@ describe('Kairo tests', function () {
 		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()
@@ -267,7 +268,7 @@ describe('Kairo tests', function () {
 		}
 	})
 
-	test(`${name} | diamond`, function () {
+	test(`${name} | diamond`, () => {
 		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`, () => {
 		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`, () => {
 		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`, () => {
 		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`, () => {
 		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,11 +1,11 @@
-import { describe, test, expect } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import {
-	state,
 	computed,
-	UNSET,
+	effect,
 	isComputed,
 	isState,
-	effect,
+	state,
+	UNSET,
 } from '../index.ts'
 
 /* === Utility Functions === */
@@ -15,7 +15,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 +23,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 +56,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 +73,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 +94,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 +102,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 +111,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,7 +127,7 @@ 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())
@@ -144,12 +144,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 +161,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 +185,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 +205,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 +223,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 +233,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 +273,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)
@@ -284,11 +284,11 @@ describe('Computed', function () {
 		let result: number = 0
 		effect({
 			signals: [derived],
-			ok: v => {
+			ok: (v): undefined => {
 				result = v
 				okCount++
 			},
-			nil: () => {
+			nil: (): undefined => {
 				nilCount++
 			},
 		})
@@ -303,7 +303,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 +350,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 +371,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 +396,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)