@e280/strata 0.2.0-0 → 0.2.0-2

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-2",
 	"description": "state management",
 	"license": "MIT",
 	"author": "Chase Moskal <chasemoskal@gmail.com>",
@@ -32,7 +32,7 @@
 		"@e280/stz": "^0.2.0"
 	},
 	"devDependencies": {
-		"@e280/science": "^0.1.1",
+		"@e280/science": "^0.1.2",
 		"@types/node": "^24.3.0",
 		"npm-run-all": "^4.1.5",
 		"typescript": "^5.9.2"

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/index.ts

@@ -4,7 +4,7 @@ export * from "./parts/readable.js"
 
 export * from "./derive.js"
 export * from "./effect.js"
-export * from "./fns.js"
+export * from "./porcelain.js"
 export * from "./lazy.js"
 export * from "./signal.js"
 export * from "./types.js"

package/s/signals/parts/hipster.ts

@@ -0,0 +1,35 @@
+
+import {Signal} from "../signal.js"
+import {SignalFn} from "../types.js"
+
+export function hipster<V>(sig: Signal<V>) {
+	function f(): V
+	function f(v: V): Promise<V>
+	function f(_v?: V): V | Promise<V> {
+		return (arguments.length === 0)
+			? sig.get()
+			: sig.set(arguments[0])
+	}
+
+	f.signal = sig
+
+	f.get = sig.get.bind(sig)
+	f.set = sig.set.bind(sig)
+	f.on = sig.on
+	f.dispose = sig.dispose.bind(sig)
+	f.publish = sig.publish.bind(sig)
+	f.fn = sig.fn.bind(sig)
+
+	Object.defineProperty(f, "value", {
+		get: () => sig.value,
+		set: (v) => sig.value = v,
+	})
+
+	Object.defineProperty(f, "sneak", {
+		get: () => sig.sneak,
+		set: (v) => sig.sneak = v,
+	})
+
+	return f as SignalFn<V>
+}
+

package/s/signals/{fns.ts → porcelain.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

@@ -1,5 +1,6 @@
 
 import {SignalOptions} from "./types.js"
+import {hipster} from "./parts/hipster.js"
 import {Reactive} from "./parts/reactive.js"
 import {tracker} from "../tracker/tracker.js"
 import {defaultCompare} from "./utils/default-compare.js"
@@ -8,11 +9,15 @@ 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
 	}
 
+	fn() {
+		return hipster(this)
+	}
+
 	async set(v: V) {
 		const isChanged = !this.#compare(this.sneak, v)
 		if (isChanged) await this.publish(v)
@@ -24,20 +29,27 @@ export class Signal<V> extends Reactive<V> {
 	}
 
 	set value(v: V) {
-		this.set(v)
+		void this.set(v)
 	}
 
-	async publish(v = this.get()) {
-		if (this.#lock) throw new Error("forbid circularity")
-		let promise = Promise.resolve()
+	async publish(v = this.sneak) {
+		// only wizards are allowed beyond this point.
+		// - the implementation is subtle
+		// - it looks wrong, but it's right
+		// - tarnished alchemists, take heed: lock engages only for sync activity of the async fns (think of the value setter!)
+
+		if (this.#lock)
+			throw new Error("forbid circularity")
+
+		let promise: Promise<any> = Promise.resolve()
 
 		try {
 			this.#lock = true
 			this.sneak = v
 			promise = Promise.all([
 				tracker.notifyWrite(this),
-				this.on.pub(v),
-			]) as any
+				this.on.publish(v),
+			])
 		}
 		finally {
 			this.#lock = false

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 "../porcelain.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 "../porcelain.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 "../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)
+	}),
+})
+