@e280/strata 0.1.0 → 0.2.0-1

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

@@ -1,11 +1,19 @@
 
+import {Lazy} from "./lazy.js"
 import {Signal} from "./signal.js"
-import {LazySignal} from "./parts/lazy.js"
-import {DerivedSignal} from "./parts/derive.js"
+import {Derive} from "./derive.js"
 
-export type Signaloid<V> = Signal<V> | DerivedSignal<V> | LazySignal<V>
+export type Signaly<V> = Signal<V> | Derive<V> | Lazy<V>
 
 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>
+

package/s/signals/utils/default-compare.ts

@@ -0,0 +1,5 @@
+
+export function defaultCompare(a: any, b: any) {
+	return a === b
+}
+

package/s/signals/utils/hipster.ts

@@ -0,0 +1,40 @@
+
+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.setPrototypeOf(f, {
+		set: sig.set.bind(sig),
+		publish: sig.publish.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/tests.test.ts

@@ -5,9 +5,9 @@ import tree from "./tree/tree.test.js"
 import signals from "./signals/signals.test.js"
 import tracker from "./tracker/tracker.test.js"
 
-import {Trunk} from "./tree/parts/trunk.js"
+import {signal} from "./signals/fns.js"
 import {effect} from "./signals/effect.js"
-import {signal} from "./signals/signal.js"
+import {Trunk} from "./tree/parts/trunk.js"
 
 await Science.run({
 	tree,

package/s/tree/parts/branch.ts

@@ -1,11 +1,11 @@
 
 import {deep} from "@e280/stz"
-import {signal} from "../../signals/signal.js"
-import {DerivedSignal} from "../../signals/parts/derive.js"
+import {derive} from "../../signals/fns.js"
+import {Derive} from "../../signals/derive.js"
 import {Branchstate, Immutable, Mutator, Options, Selector, Tree} from "./types.js"
 
 export class Branch<S extends Branchstate, ParentState extends Branchstate = any> implements Tree<S> {
-	#immutable: DerivedSignal<Immutable<S>>
+	#immutable: Derive<Immutable<S>>
 
 	constructor(
 			private parent: Tree<ParentState>,
@@ -13,7 +13,7 @@ export class Branch<S extends Branchstate, ParentState extends Branchstate = any
 			private options: Options,
 		) {
 
-		this.#immutable = signal.derive(() => {
+		this.#immutable = derive(() => {
 			const state = selector(parent.state as any)
 			return deep.freeze(options.clone(state)) as Immutable<S>
 		}, {compare: deep.equal})

package/s/tree/parts/trunk.ts

@@ -1,11 +1,12 @@
 
 import {deep} from "@e280/stz"
 import {Branch} from "./branch.js"
+import {signal} from "../../signals/fns.js"
 import {trunkSetup} from "./utils/setup.js"
+import {Derive} from "../../signals/derive.js"
+import {Signal} from "../../signals/signal.js"
 import {Chronobranch} from "./chronobranch.js"
 import {processOptions} from "./utils/process-options.js"
-import {DerivedSignal} from "../../signals/parts/derive.js"
-import {signal, Signal} from "../../signals/signal.js"
 import {Branchstate, Chronicle, Immutable, Mutator, Options, Selector, Tree, Trunkstate} from "./types.js"
 
 export class Trunk<S extends Trunkstate> implements Tree<S> {
@@ -18,7 +19,7 @@ export class Trunk<S extends Trunkstate> implements Tree<S> {
 
 	options: Options
 
-	#immutable: DerivedSignal<Immutable<S>>
+	#immutable: Derive<Immutable<S>>
 	#mutable: Signal<S>
 	#mutationLock = 0
 
@@ -44,8 +45,9 @@ export class Trunk<S extends Trunkstate> implements Tree<S> {
 			throw new Error("nested mutations are forbidden")
 		try {
 			this.#mutationLock++
-			mutator(this.#mutable())
-			const newState = this.#mutable.get()
+			const value = this.#mutable.get()
+			mutator(value)
+			const newState = value
 			const isChanged = !deep.equal(newState, oldState)
 			if (isChanged)
 				await this.overwrite(newState)

package/x/signals/derive.d.ts

@@ -0,0 +1,7 @@
+import { SignalOptions } from "./types.js";
+import { Reactive } from "./parts/reactive.js";
+export declare class Derive<V> extends Reactive<V> {
+    #private;
+    constructor(formula: () => V, options?: Partial<SignalOptions>);
+    dispose(): void;
+}

package/x/signals/derive.js

@@ -0,0 +1,28 @@
+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 extends Reactive {
+    #dispose;
+    constructor(formula, options) {
+        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();
+    }
+}
+//# sourceMappingURL=derive.js.map

package/x/signals/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","sourceRoot":"","sources":["../../s/signals/derive.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,eAAe,EAAC,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAC,QAAQ,EAAC,MAAM,qBAAqB,CAAA;AAC5C,OAAO,EAAC,OAAO,EAAC,MAAM,uBAAuB,CAAA;AAC7C,OAAO,EAAC,cAAc,EAAC,MAAM,4BAA4B,CAAA;AAEzD,MAAM,OAAO,MAAU,SAAQ,QAAW;IACzC,QAAQ,CAAY;IAEpB,YAAY,OAAgB,EAAE,OAAgC;QAC7D,MAAM,OAAO,GAAG,OAAO,EAAE,OAAO,IAAI,cAAc,CAAA;QAClD,MAAM,EAAC,MAAM,EAAE,OAAO,EAAC,GAAG,eAAe,CAAC,OAAO,EAAE,KAAK,IAAG,EAAE;YAC5D,MAAM,KAAK,GAAG,OAAO,EAAE,CAAA;YACvB,MAAM,SAAS,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;YAC7C,IAAI,SAAS,EAAE,CAAC;gBACf,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;gBAClB,MAAM,OAAO,CAAC,GAAG,CAAC;oBACjB,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC;oBACzB,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC;iBAClB,CAAC,CAAA;YACH,CAAC;QACF,CAAC,CAAC,CAAA;QACF,KAAK,CAAC,MAAM,CAAC,CAAA;QACb,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;IACxB,CAAC;IAED,OAAO;QACN,KAAK,CAAC,OAAO,EAAE,CAAA;QACf,IAAI,CAAC,QAAQ,EAAE,CAAA;IAChB,CAAC;CACD"}

package/x/signals/effect.js.map

@@ -1 +1 @@
-{"version":3,"file":"effect.js","sourceRoot":"","sources":["../../s/signals/effect.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAC,MAAM,WAAW,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,uBAAuB,CAAA;AAE7C,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,OAAO,CAAC,SAAS,CAAC,CAAA;IACjD,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,SAAS,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;QAC1C,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACxB,CAAC;IAED,OAAO,EAAC,MAAM,EAAE,OAAO,EAAC,CAAA;AACzB,CAAC"}
+{"version":3,"file":"effect.js","sourceRoot":"","sources":["../../s/signals/effect.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAC,MAAM,WAAW,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,uBAAuB,CAAA;AAE7C,MAAM,UAAU,MAAM,CACpB,SAAqB,EACrB,YAAwB,SAAS;IAGlC,OAAO,eAAe,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,OAAO,CAAA;AACrD,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,SAAkB,EAClB,YAAwB,SAAS;IAGlC,MAAM,EAAC,IAAI,EAAE,MAAM,EAAC,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;IACjD,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,SAAS,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;QAC1C,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACxB,CAAC;IAED,OAAO,EAAC,MAAM,EAAE,OAAO,EAAC,CAAA;AACzB,CAAC"}

package/x/signals/fns.d.ts

@@ -0,0 +1,12 @@
+import { Lazy } from "./lazy.js";
+import { Signal } from "./signal.js";
+import { Derive } from "./derive.js";
+import { SignalOptions } from "./types.js";
+export declare function lazy<V>(formula: () => V, options?: Partial<SignalOptions>): Lazy<V>;
+export declare function derive<V>(formula: () => V, options?: Partial<SignalOptions>): Derive<V>;
+export declare function signal<V>(value: V, options?: Partial<SignalOptions>): Signal<V>;
+export declare namespace signal {
+    var lazy: typeof import("./fns.js").lazy;
+    var derive: typeof import("./fns.js").derive;
+    var fn: <V>(value: V) => import("./types.js").SignalFn<V>;
+}

package/x/signals/fns.js

@@ -0,0 +1,16 @@
+import { Lazy } from "./lazy.js";
+import { Signal } from "./signal.js";
+import { Derive } from "./derive.js";
+export function lazy(formula, options) {
+    return new Lazy(formula, options);
+}
+export function derive(formula, options) {
+    return new Derive(formula, options);
+}
+export function signal(value, options) {
+    return new Signal(value, options);
+}
+signal.lazy = lazy;
+signal.derive = derive;
+signal.fn = (value) => signal(value).fn();
+//# sourceMappingURL=fns.js.map

package/x/signals/fns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fns.js","sourceRoot":"","sources":["../../s/signals/fns.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAA;AAC9B,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAA;AAClC,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAA;AAGlC,MAAM,UAAU,IAAI,CAClB,OAAgB,EAChB,OAAgC;IAEjC,OAAO,IAAI,IAAI,CAAI,OAAO,EAAE,OAAO,CAAC,CAAA;AACrC,CAAC;AAED,MAAM,UAAU,MAAM,CACpB,OAAgB,EAChB,OAAgC;IAEjC,OAAO,IAAI,MAAM,CAAI,OAAO,EAAE,OAAO,CAAC,CAAA;AACvC,CAAC;AAED,MAAM,UAAU,MAAM,CACpB,KAAQ,EACR,OAAgC;IAEjC,OAAO,IAAI,MAAM,CAAI,KAAK,EAAE,OAAO,CAAC,CAAA;AACrC,CAAC;AAED,MAAM,CAAC,IAAI,GAAG,IAAI,CAAA;AAClB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAA;AACtB,MAAM,CAAC,EAAE,GAAG,CAAI,KAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAA"}

package/x/signals/index.d.ts

@@ -1,5 +1,8 @@
-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/x/signals/index.js

@@ -1,6 +1,9 @@
-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";
 //# sourceMappingURL=index.js.map

package/x/signals/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../s/signals/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../s/signals/index.ts"],"names":[],"mappings":"AACA,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AAEnC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA"}

package/x/signals/lazy.d.ts

@@ -0,0 +1,8 @@
+import { SignalOptions } from "./types.js";
+import { Readable } from "./parts/readable.js";
+export declare class Lazy<V> extends Readable<V> {
+    #private;
+    constructor(formula: () => V, options?: Partial<SignalOptions>);
+    get(): V;
+    dispose(): void;
+}

package/x/signals/lazy.js

@@ -0,0 +1,37 @@
+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 extends Readable {
+    #formula;
+    #compare;
+    #dirty = false;
+    #effect;
+    constructor(formula, options) {
+        super(undefined);
+        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();
+    }
+}
+//# sourceMappingURL=lazy.js.map

package/x/signals/lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.js","sourceRoot":"","sources":["../../s/signals/lazy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,eAAe,EAAC,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAC,QAAQ,EAAC,MAAM,qBAAqB,CAAA;AAC5C,OAAO,EAAC,OAAO,EAAC,MAAM,uBAAuB,CAAA;AAC7C,OAAO,EAAC,cAAc,EAAC,MAAM,4BAA4B,CAAA;AAEzD,MAAM,OAAO,IAAQ,SAAQ,QAAW;IACvC,QAAQ,CAAS;IACjB,QAAQ,CAA6B;IACrC,MAAM,GAAG,KAAK,CAAA;IACd,OAAO,CAA0B;IAEjC,YAAY,OAAgB,EAAE,OAAgC;QAC7D,KAAK,CAAC,SAAgB,CAAC,CAAA;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,EAAE,OAAO,IAAI,cAAc,CAAA;IACnD,CAAC;IAED,GAAG;QACF,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YACnB,MAAM,EAAC,MAAM,EAAE,OAAO,EAAC,GAAG,eAAe,CACxC,IAAI,CAAC,QAAQ,EACb,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CACxB,CAAA;YACD,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;YAEnB,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAA;YACzB,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;YAC/C,IAAI,SAAS,EAAE,CAAC;gBACf,IAAI,CAAC,KAAK,GAAG,CAAC,CAAA;gBACd,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;YAC1B,CAAC;QACF,CAAC;QACD,OAAO,KAAK,CAAC,GAAG,EAAE,CAAA;IACnB,CAAC;IAED,OAAO;QACN,IAAI,IAAI,CAAC,OAAO;YACf,IAAI,CAAC,OAAO,EAAE,CAAA;IAChB,CAAC;CACD"}

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

@@ -0,0 +1,5 @@
+import { Readable } from "./readable.js";
+export declare class Reactive<V> extends Readable<V> {
+    on: import("@e280/stz").Sub<[V]>;
+    dispose(): void;
+}

package/x/signals/parts/reactive.js

@@ -0,0 +1,9 @@
+import { sub } from "@e280/stz";
+import { Readable } from "./readable.js";
+export class Reactive extends Readable {
+    on = sub();
+    dispose() {
+        this.on.clear();
+    }
+}
+//# sourceMappingURL=reactive.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.js","sourceRoot":"","sources":["../../../s/signals/parts/reactive.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,GAAG,EAAC,MAAM,WAAW,CAAA;AAC7B,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAA;AAEtC,MAAM,OAAO,QAAY,SAAQ,QAAW;IAC3C,EAAE,GAAG,GAAG,EAAO,CAAA;IAEf,OAAO;QACN,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAA;IAChB,CAAC;CACD"}

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

@@ -0,0 +1,6 @@
+export declare class Readable<V> {
+    sneak: V;
+    constructor(sneak: V);
+    get(): V;
+    get value(): V;
+}