@zeix/cause-effect 0.13.1 → 0.14.0

package/test/benchmark.test.ts

@@ -1,18 +1,22 @@
 import { describe, test, expect, mock } from 'bun:test'
-import { state, computed, effect, batch } from '../'
-import { makeGraph, runGraph, Counter } from "./util/dependency-graph"
+import { state, memo, effect, batch } from '../'
+import { makeGraph, runGraph, Counter } from './util/dependency-graph'
+import {
+	type ReactiveFramework,
+	type Computed,
+} from './util/reactive-framework'
 
 /* === Utility Functions === */
 
 const busy = () => {
-	let a = 0
+	let _a = 0
 	for (let i = 0; i < 1_00; i++) {
-		a++
+		_a++
 	}
 }
 
 const framework = {
-	name: "Cause & Effect",
+	name: 'Cause & Effect',
 	signal: <T extends {}>(initialValue: T) => {
 		const s = state<T>(initialValue)
 		return {
@@ -21,14 +25,14 @@ const framework = {
 		}
 	},
 	computed: <T extends {}>(fn: () => T) => {
-		const c = computed(fn)
+		const c = memo(fn)
 		return {
 			read: () => c.get(),
 		}
 	},
 	effect: (fn: () => void) => effect(fn),
 	withBatch: (fn: () => void) => batch(fn),
-	withBuild: (fn: () => void) => fn(),
+	withBuild: <T>(fn: () => T) => fn(),
 }
 const testPullCounts = true
 
@@ -45,7 +49,7 @@ function makeConfig() {
 }
 
 /* === Test functions === */
-	 
+
 /** some basic tests to validate the reactive framework
  * wrapper works and can run performance tests.
  */
@@ -55,30 +59,30 @@ describe('Basic test', function () {
 		framework.withBuild(() => {
 			const s = framework.signal(2)
 			const c = framework.computed(() => s.read() * 2)
-		
+
 			expect(c.read()).toEqual(4)
 		})
 	})
-	
+
 	test(`${name} | simple write`, () => {
 		framework.withBuild(() => {
 			const s = framework.signal(2)
 			const c = framework.computed(() => s.read() * 2)
 			expect(s.read()).toEqual(2)
 			expect(c.read()).toEqual(4)
-		
+
 			s.write(3)
 			expect(s.read()).toEqual(3)
 			expect(c.read()).toEqual(6)
 		})
 	})
-	
+
 	test(`${name} | static graph`, () => {
 		const config = makeConfig()
 		const counter = new Counter()
-		// @ts-expect-error
+		// @ts-expect-error - Framework object has incompatible type constraints with ReactiveFramework
 		const graph = makeGraph(framework, config, counter)
-		// @ts-expect-error
+		// @ts-expect-error - Framework object has incompatible type constraints with ReactiveFramework
 		const sum = runGraph(graph, 2, 1, framework)
 		expect(sum).toEqual(16)
 		if (testPullCounts) {
@@ -87,18 +91,18 @@ describe('Basic test', function () {
 			expect(counter.count).toBeGreaterThanOrEqual(11)
 		}
 	})
-	
+
 	test(`${name} | static graph, read 2/3 of leaves`, () => {
 		framework.withBuild(() => {
 			const config = makeConfig()
 			config.readFraction = 2 / 3
 			config.iterations = 10
 			const counter = new Counter()
-			// @ts-expect-error
+			// @ts-expect-error - Framework object has incompatible type constraints with ReactiveFramework
 			const graph = makeGraph(framework, config, counter)
-			// @ts-expect-error
+			// @ts-expect-error - Framework object has incompatible type constraints with ReactiveFramework
 			const sum = runGraph(graph, 10, 2 / 3, framework)
-		
+
 			expect(sum).toEqual(71)
 			if (testPullCounts) {
 				expect(counter.count).toEqual(41)
@@ -107,7 +111,7 @@ describe('Basic test', function () {
 			}
 		})
 	})
-	
+
 	test(`${name} | dynamic graph`, () => {
 		framework.withBuild(() => {
 			const config = makeConfig()
@@ -115,11 +119,11 @@ describe('Basic test', function () {
 			config.width = 4
 			config.totalLayers = 2
 			const counter = new Counter()
-			// @ts-expect-error
+			// @ts-expect-error - Framework object has incompatible type constraints with ReactiveFramework
 			const graph = makeGraph(framework, config, counter)
-			// @ts-expect-error
+			// @ts-expect-error - Framework object has incompatible type constraints with ReactiveFramework
 			const sum = runGraph(graph, 10, 1, framework)
-		
+
 			expect(sum).toEqual(72)
 			if (testPullCounts) {
 				expect(counter.count).toEqual(22)
@@ -128,38 +132,36 @@ describe('Basic test', function () {
 			}
 		})
 	})
-	
+
 	test(`${name} | withBuild`, () => {
 		const r = framework.withBuild(() => {
 			const s = framework.signal(2)
 			const c = framework.computed(() => s.read() * 2)
-		
+
 			expect(c.read()).toEqual(4)
 			return c.read()
 		})
-	
-		// @ts-expect-error
 		expect(r).toEqual(4)
 	})
-	
+
 	test(`${name} | effect`, () => {
-		const spy = (_v) => {}
-    	const spyMock = mock(spy)
-	
+		const spy = _v => {}
+		const spyMock = mock(spy)
+
 		const s = framework.signal(2)
 		let c: any
-	
+
 		framework.withBuild(() => {
-		  c = framework.computed(() => s.read() * 2)
-	
-		  framework.effect(() => {
-			spyMock(c.read())
-		  })
+			c = framework.computed(() => s.read() * 2)
+
+			framework.effect(() => {
+				spyMock(c.read())
+			})
 		})
 		expect(spyMock.mock.calls.length).toBe(1)
-	
+
 		framework.withBatch(() => {
-		  s.write(3)
+			s.write(3)
 		})
 		expect(s.read()).toEqual(3)
 		expect(c.read()).toEqual(6)
@@ -174,12 +176,14 @@ describe('Kairo tests', function () {
 		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 computed3 = framework.computed(
+			() => (busy(), 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
+			busy() // heavy side effect
 		})
 
 		return () => {
@@ -201,10 +205,10 @@ describe('Kairo tests', function () {
 		let last = head as { read: () => number }
 		const callCounter = new Counter()
 		for (let i = 0; i < 50; i++) {
-			let current = framework.computed(() => {
+			const current = framework.computed(() => {
 				return head.read()! + i
 			})
-			let current2 = framework.computed(() => {
+			const current2 = framework.computed(() => {
 				return current.read()! + 1
 			})
 			framework.effect(() => {
@@ -231,16 +235,16 @@ describe('Kairo tests', function () {
 	})
 
 	test(`${name} | deep propagation`, () => {
-		let len = 50
+		const len = 50
 		const head = framework.signal(0)
 		let current = head as { read: () => number }
 		for (let i = 0; i < len; i++) {
-			let c = current
+			const c = current
 			current = framework.computed(() => {
 				return c.read() + 1
 			})
 		}
-		let callCounter = new Counter()
+		const callCounter = new Counter()
 		framework.effect(() => {
 			current.read()
 			callCounter.count++
@@ -264,18 +268,16 @@ describe('Kairo tests', function () {
 	})
 
 	test(`${name} | diamond`, function () {
-		let width = 5
+		const width = 5
 		const head = framework.signal(0)
-		let current: { read(): number }[] = []
+		const current: { read(): number }[] = []
 		for (let i = 0; i < width; i++) {
-			current.push(
-				framework.computed(() => head.read() + 1)
-			)
+			current.push(framework.computed(() => head.read() + 1))
 		}
-		let sum = framework.computed(() => {
+		const sum = framework.computed(() => {
 			return current.map(x => x.read()).reduce((a, b) => a + b, 0)
 		})
-		let callCounter = new Counter()
+		const callCounter = new Counter()
 		framework.effect(() => {
 			sum.read()
 			callCounter.count++
@@ -299,15 +301,15 @@ describe('Kairo tests', function () {
 	})
 
 	test(`${name} | mux`, function () {
-		let heads = new Array(100).fill(null).map((_) => framework.signal(0))
+		const heads = new Array(100).fill(null).map(_ => framework.signal(0))
 		const mux = framework.computed(() => {
-			return Object.fromEntries(heads.map((h) => h.read()).entries())
+			return Object.fromEntries(heads.map(h => h.read()).entries())
 		})
 		const splited = heads
 			.map((_, index) => framework.computed(() => mux.read()[index]))
-			.map((x) => framework.computed(() => x.read() + 1))
+			.map(x => framework.computed(() => x.read() + 1))
 
-		splited.forEach((x) => {
+		splited.forEach(x => {
 			framework.effect(() => x.read())
 		})
 
@@ -329,15 +331,15 @@ describe('Kairo tests', function () {
 
 	test(`${name} | repeated observers`, function () {
 		const size = 30
-		let head = framework.signal(0)
-		let current = framework.computed(() => {
+		const head = framework.signal(0)
+		const current = framework.computed(() => {
 			let result = 0
 			for (let i = 0; i < size; i++) {
 				result += head.read()
 			}
 			return result
 		})
-		let callCounter = new Counter()
+		const callCounter = new Counter()
 		framework.effect(() => {
 			current.read()
 			callCounter.count++
@@ -361,28 +363,28 @@ describe('Kairo tests', function () {
 	})
 
 	test(`${name} | triangle`, function () {
-		let width = 10
-		let head = framework.signal(0)
+		const width = 10
+		const head = framework.signal(0)
 		let current = head as { read: () => number }
-		let list: { read: () => number }[] = []
+		const list: { read: () => number }[] = []
 		for (let i = 0; i < width; i++) {
-			let c = current
+			const c = current
 			list.push(current)
 			current = framework.computed(() => {
 				return c.read() + 1
 			})
 		}
-		let sum = framework.computed(() => {
-			return list.map((x) => x.read()).reduce((a, b) => a + b, 0)
+		const sum = framework.computed(() => {
+			return list.map(x => x.read()).reduce((a, b) => a + b, 0)
 		})
-		let callCounter = new Counter()
+		const callCounter = new Counter()
 		framework.effect(() => {
 			sum.read()
 			callCounter.count++
 		})
 
 		return () => {
-			const count = (number: Number) => {
+			const count = (number: number) => {
 				return new Array(number)
 					.fill(0)
 					.map((_, i) => i + 1)
@@ -406,17 +408,17 @@ describe('Kairo tests', function () {
 	})
 
 	test(`${name} | unstable`, function () {
-		let head = framework.signal(0)
+		const head = framework.signal(0)
 		const double = framework.computed(() => head.read() * 2)
 		const inverse = framework.computed(() => -head.read())
-		let current = framework.computed(() => {
+		const current = framework.computed(() => {
 			let result = 0
 			for (let i = 0; i < 20; i++) {
 				result += head.read() % 2 ? double.read() : inverse.read()
 			}
 			return result
 		})
-		let callCounter = new Counter()
+		const callCounter = new Counter()
 		framework.effect(() => {
 			current.read()
 			callCounter.count++
@@ -440,39 +442,45 @@ describe('Kairo tests', function () {
 	})
 })
 
-/* describe('$mol_wire tests', function () {
+describe('$mol_wire tests', function () {
 	const name = framework.name
 
-	test(`${name} | $mol_wire benchmark`, function() {
+	test(`${name} | $mol_wire benchmark`, function () {
 		const fib = (n: number) => {
 			if (n < 2) return 1
 			return fib(n - 1) + fib(n - 2)
 		}
-		const hard = (n: number, log: string) => {
+		const hard = (n: number, _log: string) => {
 			return n + fib(16)
 		}
 		const numbers = Array.from({ length: 5 }, (_, i) => i)
-		let res: (() => any)[] = []
-		const iter = framework.withBuild(() => {
+		const res: (() => any)[] = []
+		framework.withBuild(() => {
 			const A = framework.signal(0)
 			const B = framework.signal(0)
 			const C = framework.computed(() => (A.read() % 2) + (B.read() % 2))
 			const D = framework.computed(() =>
-				numbers.map((i) => ({ x: i + (A.read() % 2) - (B.read() % 2) }))
+				numbers.map(i => ({ x: i + (A.read() % 2) - (B.read() % 2) })),
 			)
 			const E = framework.computed(() =>
-				hard(C.read() + A.read() + D.read()[0].x, "E")
+				hard(C.read() + A.read() + D.read()[0].x, 'E'),
+			)
+			const F = framework.computed(() =>
+				hard(D.read()[2].x || B.read(), 'F'),
 			)
-			const F = framework.computed(() => hard(D.read()[2].x || B.read(), "F"))
 			const G = framework.computed(
-				() => C.read() + (C.read() || E.read() % 2) + D.read()[4].x + F.read()
+				() =>
+					C.read() +
+					(C.read() || E.read() % 2) +
+					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
@@ -494,39 +502,42 @@ describe('Kairo tests', function () {
 describe('CellX tests', function () {
 	const name = framework.name
 
-	test(`${name} | CellX benchmark`, function() {
+	test(`${name} | CellX benchmark`, function () {
 		const expected = {
-			1000: [
-				[-3, -6, -2, 2],
-				[-2, -4, 2, 3],
-			],
-			2500: [
-				[-3, -6, -2, 2],
-				[-2, -4, 2, 3],
+			10: [
+				[3, 6, 2, -2],
+				[2, 4, -2, -3],
 			],
-			5000: [
+			20: [
 				[2, 4, -1, -6],
 				[-2, 1, -4, -4],
-			]
+			],
+			50: [
+				[-2, -4, 1, 6],
+				[2, -1, 4, 4],
+			],
 		}
-		const results = {}
 
-		const cellx = (framework, layers) => {
+		const cellx = (framework: ReactiveFramework, layers: number) => {
 			const start = {
 				prop1: framework.signal(1),
 				prop2: framework.signal(2),
 				prop3: framework.signal(3),
 				prop4: framework.signal(4),
 			}
-			let layer = start
+			let layer: Record<string, Computed<number>> = start
 
 			for (let i = layers; i > 0; i--) {
 				const m = layer
 				const s = {
-				prop1: framework.computed(() => m.prop2.read()),
-				prop2: framework.computed(() => m.prop1.read() - m.prop3.read()),
-				prop3: framework.computed(() => m.prop2.read() + m.prop4.read()),
-				prop4: framework.computed(() => m.prop3.read()),
+					prop1: framework.computed(() => m.prop2.read()),
+					prop2: framework.computed(
+						() => m.prop1.read() - m.prop3.read(),
+					),
+					prop3: framework.computed(
+						() => m.prop2.read() + m.prop4.read(),
+					),
+					prop4: framework.computed(() => m.prop3.read()),
 				}
 
 				framework.effect(() => s.prop1.read())
@@ -569,10 +580,11 @@ describe('CellX tests', function () {
 		}
 
 		for (const layers in expected) {
+			// @ts-expect-error - Framework object has incompatible type constraints with ReactiveFramework
 			const [before, after] = cellx(framework, layers)
 			const [expectedBefore, expectedAfter] = expected[layers]
 			expect(before.toString()).toBe(expectedBefore.toString())
 			expect(after.toString()).toBe(expectedAfter.toString())
 		}
 	})
-}) */
+})