@e280/strata 0.2.0-0 → 0.2.0-1

package/README.md

@@ -54,11 +54,31 @@ import {signal, effect} from "@e280/strata"
   count.value // get
   count.value = 2 // set
   ```
-  value pattern is nice for this vibe
+  value pattern is nice for these vibes
   ```ts
   count.value++
   count.value += 1
   ```
+- **signal hipster fn syntax**
+  - turn a signal into a hipster fn
+    ```ts
+    const count = signal.fn(1)
+    ```
+  - now you can directly invoke it
+    ```ts
+    count() // get
+    await count(2) // set
+    ```
+  - it has all the stuff that a signal has
+    ```ts
+    count.get()
+    await count.publish(5)
+    count.on(x => console.log(x))
+    ```
+  - mint a fresh new signal fn
+    ```ts
+    const count = signal.fn(1)
+    ```
 
 ### 🚦 effects
 - **effects run when the relevant signals change**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@e280/strata",
-	"version": "0.2.0-0",
+	"version": "0.2.0-1",
 	"description": "state management",
 	"license": "MIT",
 	"author": "Chase Moskal <chasemoskal@gmail.com>",

package/s/signals/derive.ts

@@ -25,10 +25,6 @@ export class Derive<V> extends Reactive<V> {
 		this.#dispose = dispose
 	}
 
-	get value() {
-		return this.get()
-	}
-
 	dispose() {
 		super.dispose()
 		this.#dispose()

package/s/signals/fns.ts

@@ -27,4 +27,5 @@ export function signal<V>(
 
 signal.lazy = lazy
 signal.derive = derive
+signal.fn = <V>(value: V) => signal(value).fn()
 

package/s/signals/signal.ts

@@ -3,13 +3,14 @@ import {SignalOptions} from "./types.js"
 import {Reactive} from "./parts/reactive.js"
 import {tracker} from "../tracker/tracker.js"
 import {defaultCompare} from "./utils/default-compare.js"
+import { hipster } from "./utils/hipster.js"
 
 export class Signal<V> extends Reactive<V> {
 	#lock = false
 	#compare: (a: any, b: any) => boolean
 
-	constructor(sneak: V, options?: Partial<SignalOptions>) {
-		super(sneak)
+	constructor(value: V, options?: Partial<SignalOptions>) {
+		super(value)
 		this.#compare = options?.compare ?? defaultCompare
 	}
 
@@ -37,7 +38,7 @@ export class Signal<V> extends Reactive<V> {
 			promise = Promise.all([
 				tracker.notifyWrite(this),
 				this.on.pub(v),
-			]) as any
+			]).then(() => {})
 		}
 		finally {
 			this.#lock = false
@@ -46,5 +47,9 @@ export class Signal<V> extends Reactive<V> {
 		await promise
 		return v
 	}
+
+	fn() {
+		return hipster(this)
+	}
 }
 

package/s/signals/signals.test.ts

@@ -1,269 +1,16 @@
 
-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"
+import signalTest from "./tests/signal.test.js"
+import signalFnTest from "./tests/signal-fn.test.js"
+import effectTest from "./tests/effect.test.js"
+import lazyTest from "./tests/lazy.test.js"
+import deriveTest from "./tests/derive.test.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 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)
-	}),
-
-	"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)
-	}),
+	"signal": signalTest,
+	"signal.fn": signalFnTest,
+	"effect": effectTest,
+	"lazy": lazyTest,
+	"derive": deriveTest,
 })
 

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

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

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

@@ -0,0 +1,89 @@
+
+import {Science, test, expect} from "@e280/science"
+import {signal} from "../fns.js"
+import {effect} from "../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,49 @@
+
+import {Science, test, expect} from "@e280/science"
+import {lazy, signal} from "../fns.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)
+	}),
+})
+

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

@@ -0,0 +1,28 @@
+
+import {Science, test, expect} from "@e280/science"
+import {signal} from "../fns.js"
+
+export default Science.suite({
+	"get/set": test(async() => {
+		const count = signal.fn(0)
+		expect(count()).is(0)
+
+		count.value++
+		expect(count()).is(1)
+	}),
+	".on 'this' interrogation": test(async() => {
+		const count = signal.fn(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/tests/signal.test.ts

@@ -0,0 +1,63 @@
+
+import {Science, test, expect} from "@e280/science"
+import {signal} from "../fns.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)
+		}),
+	}),
+})
+

package/s/signals/types.ts

@@ -9,3 +9,11 @@ export type SignalOptions = {
 	compare: (a: any, b: any) => boolean
 }
 
+export type SignalFn<V> = {
+	(): V
+	(v: V): Promise<V>
+	(v?: V): V | Promise<V>
+
+	signal: Signal<V>
+} & Signal<V>
+