@e280/strata 0.0.0-1 → 0.0.0-10

package/s/signals/signals.test.ts

@@ -0,0 +1,285 @@
+
+import {Science, test, expect, spy} from "@e280/science"
+
+import {lazy} from "./parts/lazy.js"
+import {effect} from "./parts/effect.js"
+import {signal} from "./parts/signal.js"
+
+export default Science.suite({
+	"signal get/set value": test(async() => {
+		const count = signal(0)
+		expect(count.value).is(0)
+
+		count.value++
+		expect(count.value).is(1)
+
+		count.value = 5
+		expect(count.value).is(5)
+	}),
+
+	"signal fn syntax": test(async() => {
+		const count = signal(0)
+		expect(count()).is(0)
+
+		count(count() + 1)
+		expect(count()).is(1)
+
+		count(5)
+		expect(count()).is(5)
+	}),
+
+	"signal set and publish returns value": test(async() => {
+		const count = signal(0)
+		expect(count.value).is(0)
+
+		expect(await count.set(1)).is(1)
+		expect(await count(2)).is(2)
+		expect(await count.publish(3)).is(3)
+	}),
+
+	"signal syntax interop": test(async() => {
+		const count = signal(0)
+
+		count.value = 1
+		expect(count()).is(1)
+	}),
+
+	"signal on is not debounced": test(async() => {
+		const count = signal(1)
+		let runs = 0
+		count.on(() => void runs++)
+		await count.set(2)
+		await count.set(3)
+		expect(runs).is(2)
+	}),
+
+	"signal on only fires on change": test(async() => {
+		const count = signal(1)
+		let runs = 0
+		count.on(() => void runs++)
+		await count.set(2)
+		await count.set(2)
+		expect(runs).is(1)
+	}),
+
+	"signal on circularity forbidden": test(async() => {
+		const count = signal(1)
+		let runs = 0
+		count.on(async() => {
+			await count.set(99)
+			runs++
+		})
+		expect(async() => {
+			await count.set(2)
+		}).throwsAsync()
+		expect(runs).is(0)
+	}),
+
+	"effect tracks signal changes": test(async() => {
+		const count = signal(1)
+		let doubled = 0
+
+		effect(() => doubled = count.value * 2)
+		expect(doubled).is(2)
+
+		await count.set(3)
+		expect(doubled).is(6)
+	}),
+
+	"effect is only called when signal actually changes": test(async() => {
+		const count = signal(1)
+		let runs = 0
+		effect(() => {
+			count.get()
+			runs++
+		})
+		expect(runs).is(1)
+		await count.set(999)
+		expect(runs).is(2)
+		await count.set(999)
+		expect(runs).is(2)
+	}),
+
+	"effects are debounced": test(async() => {
+		const count = signal(1)
+		let runs = 0
+		effect(() => {
+			count.get()
+			runs++
+		})
+		expect(runs).is(1)
+		count.value++
+		count.value++
+		await count.set(count.get() + 1)
+		expect(runs).is(2)
+	}),
+
+	"effects can be disposed": test(async() => {
+		const count = signal(1)
+		let doubled = 0
+
+		const dispose = effect(() => doubled = count.value * 2)
+		expect(doubled).is(2)
+
+		await count.set(3)
+		expect(doubled).is(6)
+
+		dispose()
+		await count.set(4)
+		expect(doubled).is(6) // old value
+	}),
+
+	"signal set promise waits for effects": test(async() => {
+		const count = signal(1)
+		let doubled = 0
+
+		effect(() => doubled = count.value * 2)
+		expect(doubled).is(2)
+
+		await count.set(3)
+		expect(doubled).is(6)
+	}),
+
+	"effect only runs on change": test(async() => {
+		const sig = signal("a")
+		let runs = 0
+
+		effect(() => {
+			sig.value
+			runs++
+		})
+		expect(runs).is(1)
+
+		await sig.set("a")
+		expect(runs).is(1)
+
+		await sig.set("b")
+		expect(runs).is(2)
+	}),
+
+	"lazy values": test(async() => {
+		const a = signal(2)
+		const b = signal(3)
+		const sum = lazy(() => a.value + b.value)
+		expect(sum.value).is(5)
+
+		await a.set(5)
+		expect(sum.value).is(8)
+
+		await b.set(7)
+		expect(sum.value).is(12)
+	}),
+
+	"effect reacts to derived changes": test(async() => {
+		const a = signal(1)
+		const b = signal(10)
+		const product = signal.derive(() => a.value * b.value)
+
+		let mutations = 0
+		effect(() => {
+			void product.get()
+			mutations++
+		})
+		expect(product.value).is(10)
+		expect(mutations).is(1)
+
+		await a.set(2)
+		expect(product.value).is(20)
+		expect(mutations).is(2)
+
+		await a.set(3)
+		expect(product.value).is(30)
+		expect(mutations).is(3)
+	}),
+
+	"effect doesn't overreact to derived": test(async() => {
+		const a = signal(1)
+		const b = signal(10)
+		const product = signal.derive(() => a.value * b.value)
+
+		const derivedSpy = spy(() => {})
+		product.on(derivedSpy)
+
+		let mutations = 0
+		effect(() => {
+			a.get()
+			product.get()
+			mutations++
+		})
+		expect(product.value).is(10)
+		expect(mutations).is(1)
+		expect(derivedSpy.spy.calls.length).is(0)
+
+		await a.set(2)
+		expect(product.value).is(20)
+		expect(mutations).is(2)
+		expect(derivedSpy.spy.calls.length).is(1)
+	}),
+
+	"derived.on": test(async() => {
+		const a = signal(1)
+		const b = signal(10)
+		const product = signal.derive(() => a.value * b.value)
+		expect(product.value).is(10)
+
+		const mole = spy((_v: number) => {})
+		product.on(mole)
+		expect(mole.spy.calls.length).is(0)
+
+		await a.set(2)
+		expect(product.value).is(20)
+		expect(mole.spy.calls.length).is(1)
+		expect(mole.spy.calls[0].args[0]).is(20)
+	}),
+
+	"derived.on not called if result doesn't change": test(async() => {
+		const a = signal(1)
+		const b = signal(10)
+		const product = signal.derive(() => a.value * b.value)
+		expect(product.value).is(10)
+
+		const mole = spy((_v: number) => {})
+		product.on(mole)
+		expect(mole.spy.calls.length).is(0)
+
+		await a.set(2)
+		expect(product.value).is(20)
+		expect(mole.spy.calls.length).is(1)
+		expect(mole.spy.calls[0].args[0]).is(20)
+
+		await a.set(2)
+		expect(product.value).is(20)
+		expect(mole.spy.calls.length).is(1)
+	}),
+
+	"lazy is lazy": test(async() => {
+		const a = signal(1)
+		let runs = 0
+
+		const comp = lazy(() => {
+			runs++
+			return a.value * 10
+		})
+
+		expect(runs).is(0)
+		expect(comp.value).is(10)
+		expect(runs).is(1)
+
+		await a.set(2)
+		expect(runs).is(1)
+		expect(comp.value).is(20)
+		expect(runs).is(2)
+	}),
+
+	"lazy fn syntax": test(async() => {
+		const a = signal(2)
+		const b = signal(3)
+		const sum = lazy(() => a.value + b.value)
+		expect(sum.value).is(5)
+
+		await a.set(5)
+		expect(sum.value).is(8)
+		expect(sum()).is(8)
+	}),
+})
+

package/s/tests.test.ts

@@ -1,307 +1,66 @@
 
-import {expect, Science} from "@e280/science"
-import {Strata} from "./parts/strata.js"
+import {expect, Science, test} from "@e280/science"
 
-await Science.run({
-	"strata": Science.suite({
-		"get state": Science.test(async() => {
-			const strata = new Strata({count: 0})
-			expect(strata.state.count).is(0)
-		}),
-
-		"state is immutable": Science.test(async() => {
-			const strata = new Strata({count: 0})
-			expect(() => strata.state.count++).throws()
-		}),
-
-		"run a proper mutation": Science.test(async() => {
-			const strata = new Strata({count: 0})
-			expect(strata.state.count).is(0)
-			await strata.mutate(state => state.count++)
-			expect(strata.state.count).is(1)
-			await strata.mutate(state => state.count++)
-			expect(strata.state.count).is(2)
-		}),
+import tree from "./tree/tree.test.js"
+import signals from "./signals/signals.test.js"
+import tracker from "./tracker/tracker.test.js"
 
-		"forbidden mutation nesting": Science.test(async() => {
-			const strata = new Strata({count: 0})
-			await expect(async() => {
-				let promise!: Promise<any>
-				await strata.mutate(() => {
-					promise = strata.mutate(() => {})
-				})
-				await promise
-			}).throwsAsync()
-		}),
+import {Trunk} from "./tree/parts/trunk.js"
+import {effect} from "./signals/parts/effect.js"
+import {signal} from "./signals/parts/signal.js"
 
-		"state after mutation is frozen": Science.test(async () => {
-			const strata = new Strata({x: 1})
-			await strata.mutate(s => { s.x = 2 })
-			expect(() => strata.state.x = 3).throws()
-		}),
+await Science.run({
+	tree,
+	signals,
+	tracker,
 
-		"onMutation is published": Science.test(async() => {
-			const strata = new Strata({count: 0})
-			let mutationCount = 0
-			strata.onMutation.sub(() => {mutationCount++})
-			await strata.mutate(state => state.count++)
-			expect(mutationCount).is(1)
-		}),
+	interop: Science.suite({
+		"effect responds to trunk change": test(async() => {
+			const trunk = new Trunk({count: 1})
 
-		"onMutation is debounced": Science.test(async() => {
-			const strata = new Strata({count: 0})
-			let mutationCount = 0
-			strata.onMutation.sub(() => {mutationCount++})
-			const promise = strata.mutate(state => state.count++)
-			expect(mutationCount).is(0)
-			await promise
-			expect(mutationCount).is(1)
-		}),
+			let copy = 0
+			expect(copy).is(0)
 
-		"onMutation is fired when array item is pushed": Science.test(async() => {
-			const strata = new Strata({items: ["hello", "world"]})
-			let mutationCount = 0
-			strata.onMutation.sub(() => {mutationCount++})
-			await strata.mutate(state => state.items.push("lol"))
-			expect(mutationCount).is(1)
-			expect(strata.state.items.length).is(3)
-		}),
+			effect(() => copy = trunk.state.count)
+			expect(copy).is(1)
 
-		"prevent mutation loops": Science.test(async() => {
-			const strata = new Strata({count: 0})
-			let mutationCount = 0
-			strata.onMutation.sub(async() => {
-				mutationCount++
-				if (mutationCount > 100)
-					return
-				await strata.mutate(s => s.count++)
-			})
-			await expect(async() => {
-				await strata.mutate(state => state.count++)
-			}).throwsAsync()
-			expect(mutationCount).is(1)
+			await trunk.mutate(s => s.count++)
+			expect(copy).is(2)
 		}),
-	}),
 
-	"substrata": Science.suite({
-		"get state": Science.test(async() => {
-			const strata = new Strata({count: 0, sub: {rofls: 0}})
-			const substrata = strata.substrata(s => s.sub)
-			expect(substrata.state.rofls).is(0)
-		}),
+		"signal.set participates in flush": test(async() => {
+			let order: string[] = []
+			const count = signal(0)
 
-		"nullable selector": Science.test(async () => {
-			const strata = new Strata({
-				a: {b: 0}  as (null | {b: number}),
+			effect(() => {
+				if (count.value)
+					order.push("effect")
 			})
-			const a = strata.substrata(s => s.a)
-			expect(strata.state.a?.b).is(0)
-			expect(a.state?.b).is(0)
-			await a.mutate(a => { a!.b = 1 })
-			expect(strata.state.a?.b).is(1)
-			expect(a.state?.b).is(1)
-			await strata.mutate(s => s.a = null)
-			expect(strata.state.a?.b).is(undefined)
-			expect(a.state?.b).is(undefined)
-		}),
 
-		"composition": Science.test(async () => {
-			const strata = new Strata({a: {b: {c: 0}}})
-			const a = strata.substrata(s => s.a)
-			const b = a.substrata(s => s.b)
-			expect(strata.state.a.b.c).is(0)
-			expect(b.state.c).is(0)
-		}),
+			order.push("before")
+			await count.set(1)
+			order.push("after")
 
-		"deep mutations": Science.test(async () => {
-			const strata = new Strata({a: {b: {c: 0}}})
-			const a = strata.substrata(s => s.a)
-			const b = a.substrata(s => s.b)
-			await b.mutate(b => { b.c = 101 })
-			expect(strata.state.a.b.c).is(101)
-			expect(a.state.b.c).is(101)
-			expect(b.state.c).is(101)
-			await a.mutate(a => { a.b = {c: 102} })
-			expect(strata.state.a.b.c).is(102)
-			expect(a.state.b.c).is(102)
-			expect(b.state.c).is(102)
-			await strata.mutate(s => { s.a = {b: {c: 103}} })
-			expect(strata.state.a.b.c).is(103)
-			expect(a.state.b.c).is(103)
-			expect(b.state.c).is(103)
+			expect(order.length).is(3)
+			expect(order[0]).is("before")
+			expect(order[1]).is("effect")
+			expect(order[2]).is("after")
 		}),
 
-		"onMutation ignores outside mutations": Science.test(async() => {
-			const strata = new Strata({a: {x: 0}, b: {x: 0}})
-			const a = strata.substrata(s => s.a)
-			const b = strata.substrata(s => s.b)
-			let counted = 0
-			b.onMutation.sub(() => {counted++})
-			await a.mutate(a => a.x = 1)
-			expect(counted).is(0)
-		}),
-
-		"forbid submutation in mutation": Science.test(async() => {
-			const strata = new Strata({a: {b: 0}})
-			const a = strata.substrata(s => s.a)
-			await expect(async() => {
-				let promise!: Promise<any>
-				await strata.mutate(() => {
-					promise = a.mutate(() => {})
-				})
-				await promise
-			}).throwsAsync()
-		}),
+		"branch can include signal value": test(async() => {
+			const bingus = signal(101)
+			const trunk = new Trunk({count: 1})
+			const branch = trunk.branch(s => ({
+				count: s.count,
+				bingus: bingus.value,
+			}))
+			expect(branch.state.count).is(1)
+			expect(branch.state.bingus).is(101)
 
-		"forbid mutation in submutation": Science.test(async() => {
-			const strata = new Strata({a: {b: 0}})
-			const a = strata.substrata(s => s.a)
-			await expect(async() => {
-				let promise!: Promise<any>
-				await a.mutate(() => {
-					promise = strata.mutate(() => {})
-				})
-				await promise
-			}).throwsAsync()
+			await bingus.set(102)
+			expect(branch.state.count).is(1)
+			expect(branch.state.bingus).is(102)
 		}),
 	}),
-
-	"chronstrata": (() => {
-		const setup = () => {
-			const strata = new Strata({
-				chron: Strata.chronicle({count: 0}),
-			})
-			const chron = strata.chronstrata(64, s => s.chron)
-			return {strata, chron}
-		}
-
-		return Science.suite({
-			"get state": Science.test(async() => {
-				const {chron} = setup()
-				expect(chron.state.count).is(0)
-			}),
-
-			"mutate": Science.test(async() => {
-				const {chron} = setup()
-				expect(chron.state.count).is(0)
-				await chron.mutate(s => s.count++)
-				expect(chron.state.count).is(1)
-				await chron.mutate(s => s.count++)
-				expect(chron.state.count).is(2)
-			}),
-
-			"undoable/redoable": Science.test(async() => {
-				const {chron} = setup()
-				expect(chron.undoable).is(0)
-				expect(chron.redoable).is(0)
-				expect(chron.state.count).is(0)
-				await chron.mutate(s => s.count++)
-				expect(chron.undoable).is(1)
-				await chron.mutate(s => s.count++)
-				expect(chron.undoable).is(2)
-				await chron.undo()
-				expect(chron.undoable).is(1)
-				expect(chron.redoable).is(1)
-				await chron.undo()
-				expect(chron.undoable).is(0)
-				expect(chron.redoable).is(2)
-				await chron.redo()
-				expect(chron.undoable).is(1)
-				expect(chron.redoable).is(1)
-			}),
-
-			"undo": Science.test(async() => {
-				const {chron} = setup()
-				await chron.mutate(s => s.count++)
-				await chron.undo()
-				expect(chron.state.count).is(0)
-			}),
-
-			"redo": Science.test(async() => {
-				const {chron} = setup()
-				await chron.mutate(s => s.count++)
-				await chron.undo()
-				expect(chron.state.count).is(0)
-				await chron.redo()
-				expect(chron.state.count).is(1)
-			}),
-
-			"undo/redo well ordered": Science.test(async() => {
-				const {chron} = setup()
-				await chron.mutate(s => s.count++)
-				await chron.mutate(s => s.count++)
-				await chron.mutate(s => s.count++)
-				expect(chron.state.count).is(3)
-
-				await chron.undo()
-				expect(chron.state.count).is(2)
-
-				await chron.undo()
-				expect(chron.state.count).is(1)
-
-				await chron.redo()
-				expect(chron.state.count).is(2)
-
-				await chron.redo()
-				expect(chron.state.count).is(3)
-
-				await chron.undo()
-				expect(chron.state.count).is(2)
-
-				await chron.undo()
-				expect(chron.state.count).is(1)
-
-				await chron.undo()
-				expect(chron.state.count).is(0)
-			}),
-
-			"undo nothing does nothing": Science.test(async() => {
-				const {chron} = setup()
-				await chron.undo()
-				expect(chron.state.count).is(0)
-			}),
-
-			"redo nothing does nothing": Science.test(async() => {
-				const {chron} = setup()
-				await chron.redo()
-				expect(chron.state.count).is(0)
-			}),
-
-			"undo 2x": Science.test(async() => {
-				const {chron} = setup()
-				await chron.mutate(s => s.count++)
-				await chron.mutate(s => s.count++)
-				expect(chron.state.count).is(2)
-				await chron.undo(2)
-				expect(chron.state.count).is(0)
-			}),
-
-			"redo 2x": Science.test(async() => {
-				const {chron} = setup()
-				await chron.mutate(s => s.count++)
-				await chron.mutate(s => s.count++)
-				expect(chron.state.count).is(2)
-				await chron.undo(2)
-				expect(chron.state.count).is(0)
-				await chron.redo(2)
-				expect(chron.state.count).is(2)
-			}),
-
-			"substrata mutations are tracked": Science.test(async() => {
-				const strata = new Strata({
-					chron: Strata.chronicle({
-						group: {count: 0},
-					}),
-				})
-				const chron = strata.chronstrata(64, s => s.chron)
-				const group = chron.substrata(s => s.group)
-				expect(group.state.count).is(0)
-				await group.mutate(g => g.count = 101)
-				expect(group.state.count).is(101)
-				await chron.undo()
-				expect(group.state.count).is(0)
-			}),
-		})
-	})(),
 })
 

package/s/tracker/index.ts

@@ -0,0 +1,3 @@
+
+export * from "./tracker.js"
+

package/s/tracker/tracker.test.ts

@@ -0,0 +1,40 @@
+
+import {Science, test, expect} from "@e280/science"
+import {Tracker} from "./tracker.js"
+
+export default Science.suite({
+	"change waits for downstream effects to settle": test(async() => {
+		const tracker = new Tracker()
+		let order: string[] = []
+
+		const item = {}
+		tracker.changed(item, async () => {
+			await Promise.resolve()
+			order.push("effect")
+		})
+
+		order.push("before")
+		await tracker.change(item)
+		order.push("after")
+
+		expect(order.length).is(3)
+		expect(order[0]).is("before")
+		expect(order[1]).is("effect")
+		expect(order[2]).is("after")
+	}),
+
+	"circularity forbidden": test(async() => {
+		const tracker = new Tracker()
+		const item = {}
+
+		// effect re-publishes the same change, creating a cycle
+		tracker.changed(item, async() => {
+			await tracker.change(item)
+		})
+
+		expect(async() => {
+			await tracker.change(item)
+		}).throwsAsync()
+	}),
+})
+