@e280/strata 0.1.0 → 0.2.0-1

package/README.md

@@ -32,24 +32,18 @@ import {signal, effect} from "@e280/strata"
   ```
 - **read a signal**
   ```ts
-  count() // 0
+  count.get() // 0
   ```
 - **set a signal**
   ```ts
-  count(1)
+  count.set(1)
   ```
 - **set a signal, and await effect propagation**
   ```ts
-  await count(2)
+  await count.set(2)
   ```
 
 ### 🚦 pick your poison
-- **signal hipster fn syntax**
-  ```ts
-  count() // get
-  await count(2) // set
-  ```
-  > see the [discussion](https://github.com/e280/strata/discussions/1) about this controversial hipster-syntax
 - **signal get/set syntax**
   ```ts
   count.get() // get
@@ -60,16 +54,36 @@ 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**
   ```ts
-  effect(() => console.log(count()))
+  effect(() => console.log(count.get()))
     // 1
     // the system detects 'count' is relevant
 
@@ -84,15 +98,15 @@ import {signal, effect} from "@e280/strata"
   ```ts
   const a = signal(1)
   const b = signal(10)
-  const product = signal.derive(() => a() * b())
+  const product = signal.derive(() => a.get() * b.get())
 
-  product() // 10
+  product.get() // 10
 
   // change a dependency,
   // and the derived signal is automatically updated
   await a.set(2)
 
-  product() // 20
+  product.get() // 20
   ```
 - **signal.lazy**  
   is for making special optimizations.  

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@e280/strata",
-	"version": "0.1.0",
+	"version": "0.2.0-1",
 	"description": "state management",
 	"license": "MIT",
 	"author": "Chase Moskal <chasemoskal@gmail.com>",
@@ -29,10 +29,10 @@
 		"_tscw": "tsc -w"
 	},
 	"dependencies": {
-		"@e280/stz": "^0.1.0"
+		"@e280/stz": "^0.2.0"
 	},
 	"devDependencies": {
-		"@e280/science": "^0.1.0",
+		"@e280/science": "^0.1.1",
 		"@types/node": "^24.3.0",
 		"npm-run-all": "^4.1.5",
 		"typescript": "^5.9.2"

package/s/signals/derive.ts

@@ -0,0 +1,33 @@
+
+import {SignalOptions} from "./types.js"
+import {collectorEffect} from "./effect.js"
+import {Reactive} from "./parts/reactive.js"
+import {tracker} from "../tracker/tracker.js"
+import {defaultCompare} from "./utils/default-compare.js"
+
+export class Derive<V> extends Reactive<V> {
+	#dispose: () => void
+
+	constructor(formula: () => V, options?: Partial<SignalOptions>) {
+		const compare = options?.compare ?? defaultCompare
+		const {result, dispose} = collectorEffect(formula, async() => {
+			const value = formula()
+			const isChanged = !compare(this.sneak, value)
+			if (isChanged) {
+				this.sneak = value
+				await Promise.all([
+					tracker.notifyWrite(this),
+					this.on.pub(value),
+				])
+			}
+		})
+		super(result)
+		this.#dispose = dispose
+	}
+
+	dispose() {
+		super.dispose()
+		this.#dispose()
+	}
+}
+

package/s/signals/effect.ts

@@ -2,11 +2,19 @@
 import {debounce} from "@e280/stz"
 import {tracker} from "../tracker/tracker.js"
 
-export function effect(collector: () => void, responder: () => void = collector) {
+export function effect(
+		collector: () => void,
+		responder: () => void = collector,
+	) {
+
 	return collectorEffect(collector, responder).dispose
 }
 
-export function collectorEffect<C = void>(collector: () => C, responder: () => void = collector) {
+export function collectorEffect<C = void>(
+		collector: () => C,
+		responder: () => void = collector,
+	) {
+
 	const {seen, result} = tracker.observe(collector)
 	const fn = debounce(0, responder)
 

package/s/signals/fns.ts

@@ -0,0 +1,31 @@
+
+import {Lazy} from "./lazy.js"
+import {Signal} from "./signal.js"
+import {Derive} from "./derive.js"
+import {SignalOptions} from "./types.js"
+
+export function lazy<V>(
+		formula: () => V,
+		options?: Partial<SignalOptions>,
+	) {
+	return new Lazy<V>(formula, options)
+}
+
+export function derive<V>(
+		formula: () => V,
+		options?: Partial<SignalOptions>,
+	) {
+	return new Derive<V>(formula, options)
+}
+
+export function signal<V>(
+		value: V,
+		options?: Partial<SignalOptions>,
+	) {
+	return new Signal<V>(value, options)
+}
+
+signal.lazy = lazy
+signal.derive = derive
+signal.fn = <V>(value: V) => signal(value).fn()
+

package/s/signals/index.ts

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

package/s/signals/lazy.ts

@@ -0,0 +1,47 @@
+
+import {SignalOptions} from "./types.js"
+import {collectorEffect} from "./effect.js"
+import {Readable} from "./parts/readable.js"
+import {tracker} from "../tracker/tracker.js"
+import {defaultCompare} from "./utils/default-compare.js"
+
+export class Lazy<V> extends Readable<V> {
+	#formula: () => V
+	#compare: (a: any, b: any) => boolean
+	#dirty = false
+	#effect: (() => void) | undefined
+
+	constructor(formula: () => V, options?: Partial<SignalOptions>) {
+		super(undefined as any)
+		this.#formula = formula
+		this.#compare = options?.compare ?? defaultCompare
+	}
+
+	get() {
+		if (!this.#effect) {
+			const {result, dispose} = collectorEffect(
+				this.#formula,
+				() => this.#dirty = true,
+			)
+			this.#effect = dispose
+			this.sneak = result
+		}
+		if (this.#dirty) {
+			this.#dirty = false
+
+			const v = this.#formula()
+			const isChanged = !this.#compare(this.sneak, v)
+			if (isChanged) {
+				this.sneak = v
+				tracker.notifyWrite(this)
+			}
+		}
+		return super.get()
+	}
+
+	dispose() {
+		if (this.#effect)
+			this.#effect()
+	}
+}
+

package/s/signals/parts/reactive.ts

@@ -0,0 +1,12 @@
+
+import {sub} from "@e280/stz"
+import {Readable} from "./readable.js"
+
+export class Reactive<V> extends Readable<V> {
+	on = sub<[V]>()
+
+	dispose() {
+		this.on.clear()
+	}
+}
+

package/s/signals/parts/readable.ts

@@ -0,0 +1,16 @@
+
+import {tracker} from "../../tracker/tracker.js"
+
+export class Readable<V> {
+	constructor(public sneak: V) {}
+
+	get() {
+		tracker.notifyRead(this)
+		return this.sneak
+	}
+
+	get value() {
+		return this.get()
+	}
+}
+

package/s/signals/signal.ts

@@ -1,44 +1,55 @@
 
-import {Sub} from "@e280/stz"
-
-import {lazy} from "./parts/lazy.js"
-import {derive} from "./parts/derive.js"
 import {SignalOptions} from "./types.js"
-import {processSignalOptions, SignalCore} from "./parts/units.js"
-
-export type Signal<V> = {
-	(): V
-	(v: V): Promise<V>
-	(v?: V): V | Promise<V>
-
-	kind: "signal"
-
-	sneak: V
-	value: V
-	on: Sub<[V]>
-	get(): V
-	set(v: V): Promise<V>
-	publish(v?: V): Promise<V>
-	dispose(): void
-} & SignalCore<V>
-
-export function signal<V>(value: V, options: Partial<SignalOptions> = {}) {
-	function fn(): V
-	function fn(v: V): Promise<void>
-	function fn(v?: V): V | Promise<void> {
-		return v !== undefined
-			? (fn as any).set(v)
-			: (fn as any).get()
+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(value: V, options?: Partial<SignalOptions>) {
+		super(value)
+		this.#compare = options?.compare ?? defaultCompare
 	}
 
-	const o = processSignalOptions(options)
-	const core = new SignalCore(value, o)
-	Object.setPrototypeOf(fn, SignalCore.prototype)
-	Object.assign(fn, core)
+	async set(v: V) {
+		const isChanged = !this.#compare(this.sneak, v)
+		if (isChanged) await this.publish(v)
+		return v
+	}
 
-	return fn as Signal<V>
-}
+	get value() {
+		return this.get()
+	}
+
+	set value(v: V) {
+		this.set(v)
+	}
+
+	async publish(v = this.get()) {
+		if (this.#lock) throw new Error("forbid circularity")
+		let promise = Promise.resolve()
+
+		try {
+			this.#lock = true
+			this.sneak = v
+			promise = Promise.all([
+				tracker.notifyWrite(this),
+				this.on.pub(v),
+			]).then(() => {})
+		}
+		finally {
+			this.#lock = false
+		}
+
+		await promise
+		return v
+	}
 
-signal.lazy = lazy
-signal.derive = derive
+	fn() {
+		return hipster(this)
+	}
+}
 

package/s/signals/signals.test.ts

@@ -1,285 +1,16 @@
 
-import {Science, test, expect, spy} from "@e280/science"
-
-import {lazy} from "./parts/lazy.js"
-import {effect} from "./effect.js"
-import {signal} from "./signal.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 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)
-	}),
+	"signal": signalTest,
+	"signal.fn": signalFnTest,
+	"effect": effectTest,
+	"lazy": lazyTest,
+	"derive": deriveTest,
 })