@e280/strata 0.0.0-5 → 0.0.0-7

package/s/{parts → tree/parts}/utils/setup.ts

@@ -1,40 +1,40 @@
 
 import {debounce} from "@e280/stz"
 
-import {Strata} from "../strata.js"
-import {State, SetupOptions} from "../types.js"
+import {Trunk} from "../trunk.js"
 import {localPersistence} from "../persistence.js"
+import {Treestate, SetupOptions} from "../types.js"
 
-export async function strataSetup<S extends State>(options: SetupOptions<S>) {
+export async function trunkSetup<S extends Treestate>(options: SetupOptions<S>) {
 	const {
 		version,
 		initialState,
 		saveDebounceTime = 500,
-		persistence = localPersistence("strata"),
+		persistence = localPersistence("strataTree"),
 	} = options
 
-	const strata = new Strata<S>(initialState)
+	const trunk = new Trunk<S>(initialState)
 
 	async function load() {
 		const pickle = await persistence.store.get()
 		if (pickle && pickle.version === version)
-			await strata.overwrite(pickle.state)
+			await trunk.overwrite(pickle.state)
 	}
 
 	const save = debounce(saveDebounceTime, async() => persistence.store.set({
 		version,
-		state: strata.state,
+		state: trunk.state,
 	}))
 
 	// persistence: initial load from store
 	await load()
 
 	// persistence: save to store
-	strata.watch(save)
+	trunk.watch(save)
 
 	// cross-tab sync
 	const dispose = persistence.onChange(load)
 
-	return {strata, load, save, dispose}
+	return {trunk, load, save, dispose}
 }
 

package/s/tree/tree.test.ts

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

package/x/signals/index.js

@@ -0,0 +1,4 @@
+export * from "./parts/computed.js";
+export * from "./parts/effect.js";
+export * from "./parts/signal.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,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA"}

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

@@ -0,0 +1,14 @@
+import { SignalCore } from "./signal.js";
+export type Computed<V> = {
+    (): V;
+} & ComputedCore<V>;
+export declare function computed<V>(fn: () => V): Computed<V>;
+export declare class ComputedCore<V> extends SignalCore<V> {
+    _dirty: boolean;
+    _formula: () => V;
+    _effect: (() => void) | undefined;
+    constructor(formula: () => V);
+    get(): V;
+    set(): Promise<void>;
+    dispose(): void;
+}

package/x/signals/parts/computed.js

@@ -0,0 +1,41 @@
+import { initEffect } from "./effect.js";
+import { SignalCore } from "./signal.js";
+export function computed(fn) {
+    const core = new ComputedCore(fn);
+    function f() {
+        return f.value;
+    }
+    Object.setPrototypeOf(f, ComputedCore.prototype);
+    Object.assign(f, core);
+    return f;
+}
+export class ComputedCore extends SignalCore {
+    _dirty = false;
+    _formula;
+    _effect;
+    constructor(formula) {
+        super(undefined);
+        this._formula = formula;
+    }
+    get() {
+        if (!this._effect) {
+            const { result, dispose } = initEffect(this._formula, () => this._dirty = true);
+            this._effect = dispose;
+            this.sneak = result;
+        }
+        if (this._dirty) {
+            this._dirty = false;
+            super.set(this._formula());
+        }
+        return super.get();
+    }
+    async set() {
+        throw new Error("computed is readonly");
+    }
+    dispose() {
+        if (this._effect)
+            this._effect();
+        super.dispose();
+    }
+}
+//# sourceMappingURL=computed.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"computed.js","sourceRoot":"","sources":["../../../s/signals/parts/computed.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AACtC,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AAItC,MAAM,UAAU,QAAQ,CAAI,EAAW;IACtC,MAAM,IAAI,GAAG,IAAI,YAAY,CAAI,EAAE,CAAC,CAAA;IAEpC,SAAS,CAAC;QACT,OAAQ,CAAS,CAAC,KAAK,CAAA;IACxB,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,CAAA;IAChD,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAA;IAEtB,OAAO,CAAgB,CAAA;AACxB,CAAC;AAED,MAAM,OAAO,YAAgB,SAAQ,UAAa;IACjD,MAAM,GAAG,KAAK,CAAA;IACd,QAAQ,CAAS;IACjB,OAAO,CAA0B;IAEjC,YAAY,OAAgB;QAC3B,KAAK,CAAC,SAAgB,CAAC,CAAA;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;IACxB,CAAC;IAED,GAAG;QACF,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YACnB,MAAM,EAAC,MAAM,EAAE,OAAO,EAAC,GAAG,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;YAC7E,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;YACtB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAA;QACpB,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;YACnB,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAA;QAC3B,CAAC;QACD,OAAO,KAAK,CAAC,GAAG,EAAE,CAAA;IACnB,CAAC;IAED,KAAK,CAAC,GAAG;QACR,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAA;IACxC,CAAC;IAED,OAAO;QACN,IAAI,IAAI,CAAC,OAAO;YACf,IAAI,CAAC,OAAO,EAAE,CAAA;QACf,KAAK,CAAC,OAAO,EAAE,CAAA;IAChB,CAAC;CACD"}

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

@@ -0,0 +1,5 @@
+export declare function effect<C = void>(collector: () => C, responder?: () => void): () => void;
+export declare function initEffect<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 initEffect(collector, responder).dispose;
+}
+export function initEffect(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,CAAW,SAAkB,EAAE,YAAwB,SAAS;IACrF,OAAO,UAAU,CAAI,SAAS,EAAE,SAAS,CAAC,CAAC,OAAO,CAAA;AACnD,CAAC;AAED,MAAM,UAAU,UAAU,CAAW,SAAkB,EAAE,YAAwB,SAAS;IACzF,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/signal.d.ts

@@ -0,0 +1,18 @@
+export type Signal<V> = {
+    (): V;
+    (v: V): Promise<void>;
+    (v?: V): V | Promise<void>;
+} & SignalCore<V>;
+export declare function signal<V>(value: V): Signal<V>;
+export declare class SignalCore<V> {
+    sneak: V;
+    on: import("@e280/stz").Sub<[V]>;
+    published: Promise<V>;
+    constructor(sneak: V);
+    get(): V;
+    set(v: V): Promise<void>;
+    get value(): V;
+    set value(v: V);
+    publish(v?: V): Promise<void>;
+    dispose(): void;
+}

package/x/signals/parts/signal.js

@@ -0,0 +1,47 @@
+import { sub } from "@e280/stz";
+import { tracker } from "../../tracker/tracker.js";
+export function signal(value) {
+    const core = new SignalCore(value);
+    function fn(v) {
+        return v !== undefined
+            ? fn.set(v)
+            : fn.get();
+    }
+    Object.setPrototypeOf(fn, SignalCore.prototype);
+    Object.assign(fn, core);
+    return fn;
+}
+export class SignalCore {
+    sneak;
+    on = sub();
+    published;
+    constructor(sneak) {
+        this.sneak = sneak;
+        this.published = Promise.resolve(sneak);
+    }
+    get() {
+        tracker.see(this);
+        return this.sneak;
+    }
+    async set(v) {
+        if (v !== this.sneak)
+            await this.publish(v);
+    }
+    get value() {
+        return this.get();
+    }
+    set value(v) {
+        this.set(v);
+    }
+    async publish(v = this.get()) {
+        this.sneak = v;
+        await Promise.all([
+            tracker.change(this),
+            this.published = this.on.pub(v).then(() => v),
+        ]);
+    }
+    dispose() {
+        this.on.clear();
+    }
+}
+//# 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":"AACA,OAAO,EAAC,GAAG,EAAC,MAAM,WAAW,CAAA;AAC7B,OAAO,EAAC,OAAO,EAAC,MAAM,0BAA0B,CAAA;AAQhD,MAAM,UAAU,MAAM,CAAI,KAAQ;IACjC,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAA;IAIlC,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,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,OAAO,UAAU;IAIH;IAHnB,EAAE,GAAG,GAAG,EAAO,CAAA;IACf,SAAS,CAAY;IAErB,YAAmB,KAAQ;QAAR,UAAK,GAAL,KAAK,CAAG;QAC1B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IACxC,CAAC;IAED,GAAG;QACF,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACjB,OAAO,IAAI,CAAC,KAAK,CAAA;IAClB,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,CAAI;QACb,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK;YACnB,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IACvB,CAAC;IAED,IAAI,KAAK;QACR,OAAO,IAAI,CAAC,GAAG,EAAE,CAAA;IAClB,CAAC;IAED,IAAI,KAAK,CAAC,CAAI;QACb,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;IACZ,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE;QAC3B,IAAI,CAAC,KAAK,GAAG,CAAC,CAAA;QACd,MAAM,OAAO,CAAC,GAAG,CAAC;YACjB,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;YACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;SAC7C,CAAC,CAAA;IACH,CAAC;IAED,OAAO;QACN,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAA;IAChB,CAAC;CACD"}

package/x/signals/signals.test.d.ts

@@ -0,0 +1,18 @@
+import { Science } from "@e280/science";
+declare const _default: {
+    "signal get/set value": Science.Test;
+    "signal fn syntax": Science.Test;
+    "signal syntax interop": Science.Test;
+    "signal on is not debounced": Science.Test;
+    "signal on only fires on change": Science.Test;
+    "effect tracks signal changes": Science.Test;
+    "effect is only called when signal actually changes": Science.Test;
+    "effects are debounced": Science.Test;
+    "effects can be disposed": Science.Test;
+    "signal set promise waits for effects": Science.Test;
+    "effect only runs on change": Science.Test;
+    "computed values": Science.Test;
+    "computed is lazy": Science.Test;
+    "computed fn syntax": Science.Test;
+};
+export default _default;