@e280/strata 0.2.0-0 → 0.2.0-10

package/s/signals/signals.test.ts

@@ -1,269 +1,15 @@
 
-import {Science, test, expect, spy} from "@e280/science"
-import {effect} from "./effect.js"
-import {derive, lazy, signal} from "./fns.js"
+import {Science} from "@e280/science"
 
-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 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.publish(2)).is(2)
-	}),
-
-	"signal syntax interop": test(async() => {
-		const count = signal(0)
-		count.value = 1
-		expect(count.get()).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)
-	}),
+import effectTest from "./tests/effect.test.js"
+import signalTest from "./tests/signal.test.js"
+import derivedTest from "./tests/derived.test.js"
+import lazyTest from "./tests/lazy.test.js"
 
-	"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 = 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 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.get()).is(8)
-	}),
+export default Science.suite({
+	"effect": effectTest,
+	"signal": signalTest,
+	"derived": derivedTest,
+	"lazy": lazyTest,
 })
 

package/s/signals/tests/derived.test.ts

@@ -0,0 +1,111 @@
+
+import {Science, test, expect, spy} from "@e280/science"
+import {effect} from "../core/effect.js"
+import {derived, signal} from "../porcelain.js"
+
+export default Science.suite({
+	"basic": test(async() => {
+		const a = signal(1)
+		const b = signal(10)
+		const product = derived(() => a.get() * b.get())
+		expect(product.get()).is(10)
+
+		await a.set(2)
+		expect(product.get()).is(20)
+	}),
+
+	"effect reacts to derived changes": test(async() => {
+		const a = signal(1)
+		const b = signal(10)
+		const product = derived(() => 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.derived(() => 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.derived(() => 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.derived(() => 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)
+	}),
+
+	"hipster fns": Science.suite({
+		"basic": test(async() => {
+			const a = signal(1)
+			const b = signal(10)
+			const product = derived(() => a() * b())
+			expect(product()).is(10)
+
+			await a(2)
+			expect(product()).is(20)
+		}),
+	}),
+})
+

package/s/signals/tests/effect.test.ts

@@ -0,0 +1,89 @@
+
+import {Science, test, expect} from "@e280/science"
+import {signal} from "../porcelain.js"
+import {effect} from "../core/effect.js"
+
+export default Science.suite({
+	"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)
+	}),
+
+	"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)
+	}),
+
+	"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)
+	}),
+
+	"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)
+	}),
+
+	"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)
+	}),
+})
+

package/s/signals/tests/lazy.test.ts

@@ -0,0 +1,64 @@
+
+import {Science, test, expect} from "@e280/science"
+import {lazy, signal} from "../porcelain.js"
+
+export default Science.suite({
+	"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)
+	}),
+
+	"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 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.get()).is(8)
+	}),
+
+	"hipster fns": Science.suite({
+		"lazy values": test(async() => {
+			const a = signal(2)
+			const b = signal(3)
+			const sum = lazy(() => a() + b())
+			expect(sum()).is(5)
+
+			await a(5)
+			expect(sum()).is(8)
+
+			await b(7)
+			expect(sum()).is(12)
+		}),
+	}),
+})
+

package/s/signals/tests/signal.test.ts

@@ -0,0 +1,115 @@
+
+import {Science, test, expect} from "@e280/science"
+import {signal} from "../porcelain.js"
+
+export default Science.suite({
+	"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)
+	}),
+
+	"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.publish(2)).is(2)
+	}),
+
+	"syntax interop": test(async() => {
+		const count = signal(0)
+		count.value = 1
+		expect(count.get()).is(1)
+	}),
+
+	"on": Science.suite({
+		"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)
+		}),
+
+		"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)
+		}),
+
+		"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)
+		}),
+	}),
+
+	"hipster syntax": Science.suite({
+		"get and set": test(async() => {
+			const count = signal(0)
+			expect(count()).is(0)
+
+			count(count() + 1)
+			expect(count()).is(1)
+		}),
+
+		"old get and set still work": test(async() => {
+			const count = signal(0)
+			expect(count.get()).is(0)
+
+			count.set(count.get() + 1)
+			expect(count.get()).is(1)
+		}),
+
+		"interop": test(async() => {
+			const count = signal(0)
+
+			count(1)
+			expect(count()).is(1)
+			expect(count.get()).is(1)
+			expect(count.value).is(1)
+
+			count.set(2)
+			expect(count()).is(2)
+			expect(count.get()).is(2)
+			expect(count.value).is(2)
+
+			count.value = 3
+			expect(count()).is(3)
+			expect(count.get()).is(3)
+			expect(count.value).is(3)
+		}),
+
+		".on 'this' interrogation": test(async() => {
+			const count = signal(0)
+			expect(count()).is(0)
+
+			let reported = count()
+			count.on(x => {reported = x})
+
+			count(1)
+			expect(reported).is(1)
+
+			count.on.clear()
+			count(2)
+			expect(reported).is(1)
+		}),
+	}),
+})
+

package/s/signals/types.ts

@@ -1,11 +1,30 @@
 
-import {Lazy} from "./lazy.js"
-import {Signal} from "./signal.js"
-import {Derive} from "./derive.js"
+import {Lazy} from "./core/lazy.js"
+import {Signal} from "./core/signal.js"
+import {Derived} from "./core/derived.js"
 
-export type Signaly<V> = Signal<V> | Derive<V> | Lazy<V>
+export type Signaly<V> = Signal<V> | Derived<V> | Lazy<V>
+export type SignalyFn<V> = SignalFn<V> | DerivedFn<V> | LazyFn<V>
 
 export type SignalOptions = {
 	compare: (a: any, b: any) => boolean
 }
 
+export type SignalFn<V> = {
+	(): V
+	(v: V): Promise<V>
+	(v?: V): V | Promise<V>
+
+	core: Signal<V>
+} & Signal<V>
+
+export type LazyFn<V> = {
+	(): V
+	core: Lazy<V>
+} & Lazy<V>
+
+export type DerivedFn<V> = {
+	(): V
+	core: Derived<V>
+} & Derived<V>
+

package/s/tests.test.ts

@@ -5,8 +5,8 @@ import tree from "./tree/tree.test.js"
 import signals from "./signals/signals.test.js"
 import tracker from "./tracker/tracker.test.js"
 
-import {signal} from "./signals/fns.js"
-import {effect} from "./signals/effect.js"
+import {signal} from "./signals/porcelain.js"
+import {effect} from "./signals/core/effect.js"
 import {Trunk} from "./tree/parts/trunk.js"
 
 await Science.run({