@e280/strata 0.0.0-0 → 0.0.0-10

package/s/tree/parts/persistence.ts

@@ -0,0 +1,31 @@
+
+import {Persistence} from "./types.js"
+
+export const localPersistence = <X>(
+		key: string,
+		storage: Storage = window.localStorage,
+	): Persistence<X> => ({
+
+	store: {
+		async get() {
+			const json = storage.getItem(key)
+			return json
+				? JSON.parse(json)
+				: undefined
+		},
+		async set(state) {
+			const json = JSON.stringify(state)
+			storage.setItem(key, json)
+		},
+	},
+
+	onChange: (fn: () => void) => {
+		const listener = (event: StorageEvent) => {
+			if (event.storageArea === storage && event.key === key)
+				fn()
+		}
+		window.addEventListener("storage", listener)
+		return () => window.removeEventListener("storage", listener)
+	},
+})
+

package/s/tree/parts/trunk.ts

@@ -0,0 +1,72 @@
+
+import {deep} from "@e280/stz"
+import {Branch} from "./branch.js"
+import {trunkSetup} from "./utils/setup.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/parts/signal.js"
+import {Branchstate, Chronicle, Immutable, Mutator, Options, Selector, Tree, Trunkstate} from "./types.js"
+
+export class Trunk<S extends Trunkstate> implements Tree<S> {
+	static setup = trunkSetup
+	static chronicle = <S extends Branchstate>(state: S): Chronicle<S> => ({
+		present: state,
+		past: [],
+		future: [],
+	})
+
+	options: Options
+
+	#immutable: DerivedSignal<Immutable<S>>
+	#mutable: Signal<S>
+	#mutationLock = 0
+
+	constructor(state: S, options: Partial<Options> = {}) {
+		this.options = processOptions(options)
+		this.#mutable = signal(state)
+		this.#immutable = signal.derive(() =>
+			deep.freeze(this.options.clone(this.#mutable.get())) as Immutable<S>
+		)
+	}
+
+	get state() {
+		return this.#immutable.get()
+	}
+
+	get on() {
+		return this.#immutable.on
+	}
+
+	async mutate(mutator: Mutator<S>) {
+		const oldState = this.options.clone(this.#mutable.get())
+		if (this.#mutationLock > 0)
+			throw new Error("nested mutations are forbidden")
+		try {
+			this.#mutationLock++
+			mutator(this.#mutable())
+			const newState = this.#mutable.get()
+			const isChanged = !deep.equal(newState, oldState)
+			if (isChanged)
+				await this.overwrite(newState)
+		}
+		finally { this.#mutationLock-- }
+		return this.#immutable.get()
+	}
+
+	async overwrite(state: S) {
+		await this.#mutable.publish(state)
+	}
+
+	branch<Sub extends Branchstate>(selector: Selector<Sub, S>): Branch<Sub, S> {
+		return new Branch(this, selector, this.options)
+	}
+
+	chronobranch<Sub extends Branchstate>(
+			limit: number,
+			selector: Selector<Chronicle<Sub>, S>,
+		) {
+		return new Chronobranch(limit, this, selector, this.options)
+	}
+}
+

package/s/tree/parts/types.ts

@@ -0,0 +1,65 @@
+
+import {Branch} from "./branch.js"
+
+export type Options = {
+	clone: <X>(x: X) => X
+}
+
+export type Selector<Sub, S> = (state: S) => Sub
+export type Mutator<S> = (state: S) => void
+
+export type Trunkstate = {}
+export type Branchstate = {} | null | undefined
+
+export type Versioned<S extends Trunkstate> = {
+	state: S
+	version: number
+}
+
+export type Immutable<T> =
+	T extends (...args: any[]) => any ? T :
+	T extends readonly any[] ? ReadonlyArray<Immutable<T[number]>> :
+	T extends object ? { readonly [K in keyof T]: Immutable<T[K]> } :
+	T
+
+export type Mutable<T> =
+	T extends (...args: any[]) => any ? T :
+	T extends ReadonlyArray<infer U> ? Mutable<U>[] :
+	T extends object ? { -readonly [K in keyof T]: Mutable<T[K]> } :
+	T
+
+export type Tree<S extends Branchstate> = {
+	get state(): Immutable<S>
+	on(fn: (state: Immutable<S>) => void): () => void
+	mutate(mutator: Mutator<S>): Promise<Immutable<S>>
+	branch<Sub extends Branchstate>(selector: Selector<Sub, S>): Branch<Sub, S>
+}
+
+export type SetupOptions<S extends Trunkstate> = {
+	version: number
+	initialState: S
+	saveDebounceTime?: number
+	persistence?: Persistence<Versioned<S>>
+}
+
+export type Chronicle<S extends Branchstate> = {
+	// [abc] d [efg]
+	//    \   \   \
+	//     \   \   future
+	//      \   present
+	//       past
+	past: S[]
+	present: S
+	future: S[]
+}
+
+export type EzStore<X> = {
+	get(): Promise<X | undefined>
+	set(state: X | undefined): Promise<void>
+}
+
+export type Persistence<X> = {
+	store: EzStore<X>
+	onChange: (fn: () => void) => (() => void)
+}
+

package/s/{parts → tree/parts}/utils/process-options.ts

@@ -2,6 +2,6 @@
 import {Options} from "../types.js"
 
 export const processOptions = (options: Partial<Options>): Options => ({
-	clone: options.clone ?? structuredClone,
+	clone: options.clone ?? (<X>(x: X) => structuredClone(x)),
 })
 

package/s/tree/parts/utils/setup.ts

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

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,3 +1,3 @@
-export { Strata } from "./parts/strata.js";
-export { Substrata } from "./parts/substrata.js";
-export { Options, Mutator, Selector } from "./parts/types.js";
+export * from "./signals/index.js";
+export * from "./tracker/index.js";
+export * from "./tree/index.js";

package/x/index.js

@@ -1,3 +1,4 @@
-export { Strata } from "./parts/strata.js";
-export { Substrata } from "./parts/substrata.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,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAA;AACxC,OAAO,EAAC,SAAS,EAAC,MAAM,sBAAsB,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;
+}