@e280/strata 0.0.0-1 → 0.0.0-10

package/s/tree/tree.test.ts

@@ -0,0 +1,316 @@
+
+import {nap} from "@e280/stz"
+import {Science, expect} from "@e280/science"
+
+import {Trunk} from "./parts/trunk.js"
+import {effect} from "../signals/parts/effect.js"
+
+export default Science.suite({
+	"trunk": Science.suite({
+		"get state": Science.test(async() => {
+			const trunk = new Trunk({count: 0})
+			expect(trunk.state.count).is(0)
+		}),
+
+		"state is immutable": Science.test(async() => {
+			const trunk = new Trunk({count: 0})
+			expect(() => (trunk.state as any).count++).throws()
+		}),
+
+		"run a proper mutation": Science.test(async() => {
+			const trunk = new Trunk({count: 0})
+			expect(trunk.state.count).is(0)
+			await trunk.mutate(state => state.count++)
+			expect(trunk.state.count).is(1)
+			await trunk.mutate(state => state.count++)
+			expect(trunk.state.count).is(2)
+		}),
+
+		"forbidden mutation nesting": Science.test(async() => {
+			const trunk = new Trunk({count: 0})
+			await expect(async() => {
+				let promise!: Promise<any>
+				await trunk.mutate(() => {
+					promise = trunk.mutate(() => {})
+				})
+				await promise
+			}).throwsAsync()
+		}),
+
+		"state after mutation is frozen": Science.test(async () => {
+			const trunk = new Trunk({x: 1})
+			await trunk.mutate(s => { s.x = 2 })
+			expect(() => (trunk.state as any).x = 3).throws()
+		}),
+
+		"effect reacts to trunk mutation": Science.test(async() => {
+			const trunk = new Trunk({count: 0})
+			await nap(10)
+			let mutationCount = 0
+			effect(() => {
+				void trunk.state.count
+				mutationCount++
+			})
+			expect(mutationCount).is(1)
+			await trunk.mutate(state => state.count++)
+			expect(mutationCount).is(2)
+		}),
+
+		"signal.on is debounced": Science.test(async() => {
+			const trunk = new Trunk({count: 0})
+			let mutationCount = 0
+			trunk.on.sub(() => {mutationCount++})
+			const promise = trunk.mutate(state => state.count++)
+			expect(mutationCount).is(0)
+			await promise
+			expect(mutationCount).is(1)
+		}),
+
+		"listeners are fired when array item is pushed": Science.test(async() => {
+			const trunk = new Trunk({items: ["hello", "world"]})
+			let mutationCount = 0
+			trunk.on.sub(() => {mutationCount++})
+			await trunk.mutate(state => state.items.push("lol"))
+			expect(mutationCount).is(1)
+			expect(trunk.state.items.length).is(3)
+		}),
+
+		"prevent mutation loops": Science.test(async() => {
+			const trunk = new Trunk({count: 0})
+			let mutationCount = 0
+			trunk.on.sub(async() => {
+				mutationCount++
+				if (mutationCount > 100)
+					return
+				await trunk.mutate(s => s.count++)
+			})
+			await expect(async() => {
+				await trunk.mutate(state => state.count++)
+			}).throwsAsync()
+			expect(mutationCount).is(1)
+		}),
+	}),
+
+	"branch": Science.suite({
+		"get state": Science.test(async() => {
+			const trunk = new Trunk({count: 0, sub: {rofls: 0}})
+			const branch = trunk.branch(s => s.sub)
+			expect(branch.state.rofls).is(0)
+		}),
+
+		"nullable selector": Science.test(async () => {
+			const trunk = new Trunk({
+				a: {b: 0}  as (null | {b: number}),
+			})
+			const a = trunk.branch(s => s.a)
+			expect(trunk.state.a?.b).is(0)
+			expect(a.state?.b).is(0)
+			await a.mutate(a => { a!.b = 1 })
+			expect(trunk.state.a?.b).is(1)
+			expect(a.state?.b).is(1)
+			await trunk.mutate(s => s.a = null)
+			expect(trunk.state.a?.b).is(undefined)
+			expect(a.state?.b).is(undefined)
+		}),
+
+		"composition": Science.test(async () => {
+			const trunk = new Trunk({a: {b: {c: 0}}})
+			const a = trunk.branch(s => s.a)
+			const b = a.branch(s => s.b)
+			expect(trunk.state.a.b.c).is(0)
+			expect(b.state.c).is(0)
+		}),
+
+		"deep mutations": Science.test(async () => {
+			const trunk = new Trunk({a: {b: {c: 0}}})
+			const a = trunk.branch(s => s.a)
+			const b = a.branch(s => s.b)
+			await b.mutate(b => { b.c = 101 })
+			expect(trunk.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(trunk.state.a.b.c).is(102)
+			expect(a.state.b.c).is(102)
+			expect(b.state.c).is(102)
+			await trunk.mutate(s => { s.a = {b: {c: 103}} })
+			expect(trunk.state.a.b.c).is(103)
+			expect(a.state.b.c).is(103)
+			expect(b.state.c).is(103)
+		}),
+
+		"signal.on ignores outside mutations": Science.test(async() => {
+			const trunk = new Trunk({a: {x: 0}, b: {x: 0}})
+			const a = trunk.branch(s => s.a)
+			const b = trunk.branch(s => s.b)
+			let counted = 0
+			b.on.sub(() => {counted++})
+			expect(counted).is(0)
+			await a.mutate(a => a.x = 1)
+			expect(counted).is(0)
+		}),
+
+		"forbid submutation in mutation": Science.test(async() => {
+			const trunk = new Trunk({a: {b: 0}})
+			const a = trunk.branch(s => s.a)
+			await expect(async() => {
+				let promise!: Promise<any>
+				await trunk.mutate(() => {
+					promise = a.mutate(() => {})
+				})
+				await promise
+			}).throwsAsync()
+		}),
+
+		"forbid mutation in submutation": Science.test(async() => {
+			const trunk = new Trunk({a: {b: 0}})
+			const a = trunk.branch(s => s.a)
+			await expect(async() => {
+				let promise!: Promise<any>
+				await a.mutate(() => {
+					promise = trunk.mutate(() => {})
+				})
+				await promise
+			}).throwsAsync()
+		}),
+	}),
+
+	"chronobranch": (() => {
+		const setup = () => {
+			const trunk = new Trunk({
+				chron: Trunk.chronicle({count: 0}),
+			})
+			const chron = trunk.chronobranch(64, s => s.chron)
+			return {trunk, 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 Trunk({
+					chron: Trunk.chronicle({
+						group: {count: 0},
+					}),
+				})
+				const chron = strata.chronobranch(64, s => s.chron)
+				const group = chron.branch(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/x/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./parts/chronstrata.js";
-export * from "./parts/strata.js";
-export * from "./parts/substrata.js";
-export * from "./parts/types.js";
+export * from "./signals/index.js";
+export * from "./tracker/index.js";
+export * from "./tree/index.js";

package/x/index.js

@@ -1,5 +1,4 @@
-export * from "./parts/chronstrata.js";
-export * from "./parts/strata.js";
-export * from "./parts/substrata.js";
-export * from "./parts/types.js";
+export * from "./signals/index.js";
+export * from "./tracker/index.js";
+export * from "./tree/index.js";
 //# sourceMappingURL=index.js.map

package/x/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../s/index.ts"],"names":[],"mappings":"AACA,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../s/index.ts"],"names":[],"mappings":"AACA,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA"}

package/x/signals/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./parts/lazy.js";
+export * from "./parts/effect.js";
+export * from "./parts/signal.js";
+export * from "./parts/types.js";

package/x/signals/index.js

@@ -0,0 +1,5 @@
+export * from "./parts/lazy.js";
+export * from "./parts/effect.js";
+export * from "./parts/signal.js";
+export * from "./parts/types.js";
+//# sourceMappingURL=index.js.map

package/x/signals/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../s/signals/index.ts"],"names":[],"mappings":"AACA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA"}

package/x/signals/parts/derive.d.ts

@@ -0,0 +1,12 @@
+import { Sub } from "@e280/stz";
+import { SignalOptions } from "./types.js";
+export type DerivedSignal<V> = {
+    (): V;
+    kind: "derived";
+    sneak: V;
+    on: Sub<[V]>;
+    get(): V;
+    get value(): V;
+    dispose(): void;
+};
+export declare function derive<V>(formula: () => V, options?: Partial<SignalOptions>): DerivedSignal<V>;

package/x/signals/parts/derive.js

@@ -0,0 +1,12 @@
+import { DerivedCore, processSignalOptions } from "./units.js";
+export function derive(formula, options = {}) {
+    function fn() {
+        return fn.value;
+    }
+    const o = processSignalOptions(options);
+    const core = DerivedCore.make(fn, formula, o);
+    Object.setPrototypeOf(fn, DerivedCore.prototype);
+    Object.assign(fn, core);
+    return fn;
+}
+//# sourceMappingURL=derive.js.map

package/x/signals/parts/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","sourceRoot":"","sources":["../../../s/signals/parts/derive.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,WAAW,EAAE,oBAAoB,EAAC,MAAM,YAAY,CAAA;AAa5D,MAAM,UAAU,MAAM,CAAI,OAAgB,EAAE,UAAkC,EAAE;IAC/E,SAAS,EAAE;QACV,OAAQ,EAAU,CAAC,KAAK,CAAA;IACzB,CAAC;IAED,MAAM,CAAC,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAA;IACvC,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,CAAI,EAAS,EAAE,OAAO,EAAE,CAAC,CAAC,CAAA;IACvD,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;IAChD,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;IAEvB,OAAO,EAAsB,CAAA;AAC9B,CAAC"}

package/x/signals/parts/effect.d.ts

@@ -0,0 +1,5 @@
+export declare function effect(collector: () => void, responder?: () => void): () => void;
+export declare function collectorEffect<C = void>(collector: () => C, responder?: () => void): {
+    result: C;
+    dispose: () => void;
+};

package/x/signals/parts/effect.js

@@ -0,0 +1,17 @@
+import { debounce } from "@e280/stz";
+import { tracker } from "../../tracker/tracker.js";
+export function effect(collector, responder = collector) {
+    return collectorEffect(collector, responder).dispose;
+}
+export function collectorEffect(collector, responder = collector) {
+    const { seen, result } = tracker.seen(collector);
+    const fn = debounce(0, responder);
+    const disposers = [];
+    const dispose = () => disposers.forEach(d => d());
+    for (const saw of seen) {
+        const dispose = tracker.changed(saw, fn);
+        disposers.push(dispose);
+    }
+    return { result, dispose };
+}
+//# sourceMappingURL=effect.js.map

package/x/signals/parts/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","sourceRoot":"","sources":["../../../s/signals/parts/effect.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAC,MAAM,WAAW,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,0BAA0B,CAAA;AAEhD,MAAM,UAAU,MAAM,CAAC,SAAqB,EAAE,YAAwB,SAAS;IAC9E,OAAO,eAAe,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,OAAO,CAAA;AACrD,CAAC;AAED,MAAM,UAAU,eAAe,CAAW,SAAkB,EAAE,YAAwB,SAAS;IAC9F,MAAM,EAAC,IAAI,EAAE,MAAM,EAAC,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IAC9C,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;IAEjC,MAAM,SAAS,GAAmB,EAAE,CAAA;IACpC,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAA;IAEjD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;QACxC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACxB,CAAC;IAED,OAAO,EAAC,MAAM,EAAE,OAAO,EAAC,CAAA;AACzB,CAAC"}

package/x/signals/parts/lazy.d.ts

@@ -0,0 +1,10 @@
+import { SignalOptions } from "./types.js";
+export type LazySignal<V> = {
+    (): V;
+    kind: "lazy";
+    sneak: V;
+    get(): V;
+    get value(): V;
+    dispose(): void;
+};
+export declare function lazy<V>(formula: () => V, options?: Partial<SignalOptions>): LazySignal<V>;

package/x/signals/parts/lazy.js

@@ -0,0 +1,12 @@
+import { LazyCore, processSignalOptions } from "./units.js";
+export function lazy(formula, options = {}) {
+    function fn() {
+        return fn.value;
+    }
+    const o = processSignalOptions(options);
+    const core = new LazyCore(formula, o);
+    Object.setPrototypeOf(fn, LazyCore.prototype);
+    Object.assign(fn, core);
+    return fn;
+}
+//# sourceMappingURL=lazy.js.map

package/x/signals/parts/lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.js","sourceRoot":"","sources":["../../../s/signals/parts/lazy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,QAAQ,EAAE,oBAAoB,EAAC,MAAM,YAAY,CAAA;AAYzD,MAAM,UAAU,IAAI,CAAI,OAAgB,EAAE,UAAkC,EAAE;IAC7E,SAAS,EAAE;QACV,OAAQ,EAAU,CAAC,KAAK,CAAA;IACzB,CAAC;IAED,MAAM,CAAC,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAA;IACvC,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAI,OAAO,EAAE,CAAC,CAAC,CAAA;IACxC,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAA;IAC7C,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;IAEvB,OAAO,EAAmB,CAAA;AAC3B,CAAC"}

package/x/signals/parts/signal.d.ts

@@ -0,0 +1,21 @@
+import { Sub } from "@e280/stz";
+import { SignalOptions } from "./types.js";
+import { SignalCore } from "./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 declare function signal<V>(value: V, options?: Partial<SignalOptions>): Signal<V>;
+export declare namespace signal {
+    var lazy: typeof import("./lazy.js").lazy;
+    var derive: typeof import("./derive.js").derive;
+}

package/x/signals/parts/signal.js

@@ -0,0 +1,18 @@
+import { lazy } from "./lazy.js";
+import { derive } from "./derive.js";
+import { processSignalOptions, SignalCore } from "./units.js";
+export function signal(value, options = {}) {
+    function fn(v) {
+        return v !== undefined
+            ? fn.set(v)
+            : fn.get();
+    }
+    const o = processSignalOptions(options);
+    const core = new SignalCore(value, o);
+    Object.setPrototypeOf(fn, SignalCore.prototype);
+    Object.assign(fn, core);
+    return fn;
+}
+signal.lazy = lazy;
+signal.derive = derive;
+//# sourceMappingURL=signal.js.map

package/x/signals/parts/signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.js","sourceRoot":"","sources":["../../../s/signals/parts/signal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAA;AAC9B,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAA;AAElC,OAAO,EAAC,oBAAoB,EAAE,UAAU,EAAC,MAAM,YAAY,CAAA;AAkB3D,MAAM,UAAU,MAAM,CAAI,KAAQ,EAAE,UAAkC,EAAE;IAGvE,SAAS,EAAE,CAAC,CAAK;QAChB,OAAO,CAAC,KAAK,SAAS;YACrB,CAAC,CAAE,EAAU,CAAC,GAAG,CAAC,CAAC,CAAC;YACpB,CAAC,CAAE,EAAU,CAAC,GAAG,EAAE,CAAA;IACrB,CAAC;IAED,MAAM,CAAC,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAA;IACvC,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IACrC,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,UAAU,CAAC,SAAS,CAAC,CAAA;IAC/C,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;IAEvB,OAAO,EAAe,CAAA;AACvB,CAAC;AAED,MAAM,CAAC,IAAI,GAAG,IAAI,CAAA;AAClB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAA"}

package/x/signals/parts/types.d.ts

@@ -0,0 +1,7 @@
+import { Signal } from "./signal.js";
+import { LazySignal } from "./lazy.js";
+import { DerivedSignal } from "./derive.js";
+export type Signaloid<V> = Signal<V> | DerivedSignal<V> | LazySignal<V>;
+export type SignalOptions = {
+    compare: (a: any, b: any) => boolean;
+};

package/x/signals/parts/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../s/signals/parts/types.ts"],"names":[],"mappings":""}

package/x/signals/parts/units.d.ts

@@ -0,0 +1,43 @@
+import { SignalOptions } from "./types.js";
+export declare function processSignalOptions(options?: Partial<SignalOptions>): {
+    compare: (a: any, b: any) => boolean;
+};
+export declare class ReadableSignal<V> {
+    sneak: V;
+    constructor(sneak: V);
+    get(): V;
+    get value(): V;
+}
+export declare class ReactiveSignal<V> extends ReadableSignal<V> {
+    on: import("@e280/stz").Sub<[V]>;
+    dispose(): void;
+}
+export declare class SignalCore<V> extends ReactiveSignal<V> {
+    _options: SignalOptions;
+    kind: "signal";
+    _lock: boolean;
+    constructor(sneak: V, _options: SignalOptions);
+    set(v: V): Promise<V>;
+    get value(): V;
+    set value(v: V);
+    publish(v?: V): Promise<V>;
+}
+export declare class LazyCore<V> extends ReadableSignal<V> {
+    _formula: () => V;
+    _options: SignalOptions;
+    kind: "lazy";
+    _dirty: boolean;
+    _effect: (() => void) | undefined;
+    constructor(_formula: () => V, _options: SignalOptions);
+    get(): V;
+    get value(): V;
+    dispose(): void;
+}
+export declare class DerivedCore<V> extends ReactiveSignal<V> {
+    _effect: () => void;
+    static make<V>(that: DerivedCore<V>, formula: () => V, options: SignalOptions): DerivedCore<V>;
+    kind: "derived";
+    constructor(initialValue: V, _effect: () => void);
+    get value(): V;
+    dispose(): void;
+}

package/x/signals/parts/units.js

@@ -0,0 +1,133 @@
+import { sub } from "@e280/stz";
+import { collectorEffect } from "./effect.js";
+import { tracker } from "../../tracker/tracker.js";
+const defaultSignalOptions = {
+    compare: (a, b) => a === b
+};
+export function processSignalOptions(options = {}) {
+    return { ...defaultSignalOptions, ...options };
+}
+export class ReadableSignal {
+    sneak;
+    constructor(sneak) {
+        this.sneak = sneak;
+    }
+    get() {
+        tracker.see(this);
+        return this.sneak;
+    }
+    get value() {
+        return this.get();
+    }
+}
+export class ReactiveSignal extends ReadableSignal {
+    on = sub();
+    dispose() {
+        this.on.clear();
+    }
+}
+export class SignalCore extends ReactiveSignal {
+    _options;
+    kind = "signal";
+    _lock = false;
+    constructor(sneak, _options) {
+        super(sneak);
+        this._options = _options;
+    }
+    async set(v) {
+        const isChanged = !this._options.compare(this.sneak, v);
+        if (isChanged)
+            await this.publish(v);
+        return v;
+    }
+    get value() {
+        return this.get();
+    }
+    set value(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.change(this),
+                this.on.pub(v),
+            ]);
+        }
+        finally {
+            this._lock = false;
+        }
+        await promise;
+        return v;
+    }
+}
+export class LazyCore extends ReadableSignal {
+    _formula;
+    _options;
+    kind = "lazy";
+    _dirty = false;
+    _effect;
+    constructor(_formula, _options) {
+        super(undefined);
+        this._formula = _formula;
+        this._options = _options;
+    }
+    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._options.compare(this.sneak, v);
+            if (isChanged) {
+                this.sneak = v;
+                tracker.change(this);
+            }
+        }
+        return super.get();
+    }
+    get value() {
+        return this.get();
+    }
+    dispose() {
+        if (this._effect)
+            this._effect();
+    }
+}
+export class DerivedCore extends ReactiveSignal {
+    _effect;
+    static make(that, formula, options) {
+        const { result, dispose } = collectorEffect(formula, async () => {
+            const value = formula();
+            const isChanged = !options.compare(that.sneak, value);
+            if (isChanged) {
+                that.sneak = value;
+                await Promise.all([
+                    tracker.change(that),
+                    that.on.pub(value),
+                ]);
+            }
+        });
+        return new this(result, dispose);
+    }
+    kind = "derived";
+    constructor(initialValue, _effect) {
+        super(initialValue);
+        this._effect = _effect;
+    }
+    get value() {
+        return this.get();
+    }
+    dispose() {
+        super.dispose();
+        this._effect();
+    }
+}
+//# sourceMappingURL=units.js.map