@zeix/cause-effect 0.13.2 → 0.14.0

package/test/benchmark.test.ts

@@ -1,13 +1,17 @@
 import { describe, test, expect, mock } from 'bun:test'
-import { state, computed, effect, batch } from '../'
+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++
 	}
 }
 
@@ -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
 
@@ -76,9 +80,9 @@ describe('Basic test', function () {
 	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) {
@@ -94,9 +98,9 @@ describe('Basic test', function () {
 			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)
@@ -115,9 +119,9 @@ 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)
@@ -137,8 +141,6 @@ describe('Basic test', function () {
 			expect(c.read()).toEqual(4)
 			return c.read()
 		})
-
-		// @ts-expect-error
 		expect(r).toEqual(4)
 	})
 
@@ -203,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(() => {
@@ -233,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++
@@ -266,16 +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))
 		}
-		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,7 +301,7 @@ 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())
 		})
@@ -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(() => {
+		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())
 		}
 	})
-}) */
+})