@e280/strata 0.0.0-7 → 0.0.0-9

package/s/tree/parts/branch.ts

@@ -1,19 +1,11 @@
 
-import {debounce, deep, sub} from "@e280/stz"
-
-import {Chronobranch} from "./chronobranch.js"
-import {tracker} from "../../tracker/tracker.js"
-import {Chronicle, Mutator, Options, Selector, Tree, Branchstate} from "./types.js"
+import {deep} from "@e280/stz"
+import {signal} from "../../signals/parts/signal.js"
+import {DerivedSignal} from "../../signals/parts/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> {
-	dispose: () => void
-	watch = sub<[state: S]>()
-
-	#immutable: S
-	#dispatchMutation = debounce(0, async(state: S) => {
-		await this.watch.pub(state)
-		await tracker.change(this)
-	})
+	#immutable: DerivedSignal<Immutable<S>>
 
 	constructor(
 			private parent: Tree<ParentState>,
@@ -21,44 +13,29 @@ export class Branch<S extends Branchstate, ParentState extends Branchstate = any
 			private options: Options,
 		) {
 
-		const state = this.selector(this.parent.state)
-		this.#immutable = deep.freeze(this.options.clone(state))
-
-		this.dispose = this.parent.watch(async parentState => {
-			const oldState = this.#immutable
-			const newState = this.selector(parentState)
-			const isChanged = !deep.equal(newState, oldState)
-			if (isChanged) {
-				this.#updateState(newState)
-				const immutable = this.state
-				await this.#dispatchMutation(immutable)
-			}
-		})
+		this.#immutable = signal.derive(() => {
+			const state = selector(parent.state as any)
+			return deep.freeze(options.clone(state)) as Immutable<S>
+		}, {compare: deep.equal})
 	}
 
-	#updateState(state: S) {
-		this.#immutable = deep.freeze(this.options.clone(state))
+	get state() {
+		return this.#immutable.get()
 	}
 
-	get state(): S {
-		tracker.see(this)
-		return this.#immutable
+	get on() {
+		return this.#immutable.on
 	}
 
 	async mutate(mutator: Mutator<S>) {
-		await this.parent.mutate(parentState => mutator(this.selector(parentState)))
-		return this.#immutable
+		await this.parent.mutate(parentState =>
+			mutator(this.selector(parentState))
+		)
+		return this.#immutable.get()
 	}
 
 	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/chronobranch.ts

@@ -1,9 +1,9 @@
 
 import {Branch} from "./branch.js"
-import {Chronicle, Mutator, Options, Selector, Tree, Branchstate} from "./types.js"
+import {Branchstate, Chronicle, Immutable, Mutator, Options, Selector, Tree} from "./types.js"
 
 export class Chronobranch<S extends Branchstate, ParentState extends Branchstate = any> implements Tree<S> {
-	#substrata: Branch<Chronicle<S>, ParentState>
+	#branch: Branch<Chronicle<S>, ParentState>
 
 	constructor(
 			public limit: number,
@@ -11,30 +11,30 @@ export class Chronobranch<S extends Branchstate, ParentState extends Branchstate
 			public selector: Selector<Chronicle<S>, ParentState>,
 			public options: Options,
 		) {
-		this.#substrata = parent.branch(selector)
+		this.#branch = parent.branch(selector)
 	}
 
 	get state() {
-		return this.#substrata.state.present
+		return this.#branch.state.present
 	}
 
 	get undoable() {
-		return this.#substrata.state.past.length
+		return this.#branch.state.past.length
 	}
 
 	get redoable() {
-		return this.#substrata.state.future.length
+		return this.#branch.state.future.length
 	}
 
-	watch(fn: (state: S) => void) {
-		return this.#substrata.watch(chronicle => fn(chronicle.present))
+	on(fn: (state: Immutable<S>) => void) {
+		return this.#branch.on(chronicle => fn(chronicle.present))
 	}
 
 	/** progress forwards in history */
 	async mutate(mutator: Mutator<S>) {
 		const limit = Math.max(0, this.limit)
-		const snapshot = this.options.clone(this.#substrata.state.present)
-		await this.#substrata.mutate(chronicle => {
+		const snapshot = this.options.clone(this.#branch.state.present) as S
+		await this.#branch.mutate(chronicle => {
 			mutator(chronicle.present)
 			chronicle.past.push(snapshot)
 			chronicle.past = chronicle.past.slice(-limit)
@@ -45,7 +45,7 @@ export class Chronobranch<S extends Branchstate, ParentState extends Branchstate
 
 	/** step backwards into the past, by n steps */
 	async undo(n = 1) {
-		await this.#substrata.mutate(chronicle => {
+		await this.#branch.mutate(chronicle => {
 			const snapshots = chronicle.past.slice(-n)
 			if (snapshots.length >= n) {
 				const oldPresent = chronicle.present
@@ -58,7 +58,7 @@ export class Chronobranch<S extends Branchstate, ParentState extends Branchstate
 
 	/** step forwards into the future, by n steps */
 	async redo(n = 1) {
-		await this.#substrata.mutate(chronicle => {
+		await this.#branch.mutate(chronicle => {
 			const snapshots = chronicle.future.slice(0, n)
 			if (snapshots.length >= n) {
 				const oldPresent = chronicle.present
@@ -71,7 +71,7 @@ export class Chronobranch<S extends Branchstate, ParentState extends Branchstate
 
 	/** wipe past and future snapshots */
 	async wipe() {
-		await this.#substrata.mutate(chronicle => {
+		await this.#branch.mutate(chronicle => {
 			chronicle.past = []
 			chronicle.future = []
 		})

package/s/tree/parts/trunk.ts

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

package/s/tree/parts/types.ts

@@ -8,22 +8,34 @@ export type Options = {
 export type Selector<Sub, S> = (state: S) => Sub
 export type Mutator<S> = (state: S) => void
 
-export type Treestate = {}
+export type Trunkstate = {}
 export type Branchstate = {} | null | undefined
 
-export type Versioned<S extends Treestate> = {
+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> = {
-	readonly state: S
-	watch(fn: (s: S) => void): () => void
-	mutate(mutator: Mutator<S>): Promise<S>
+	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 Treestate> = {
+export type SetupOptions<S extends Trunkstate> = {
 	version: number
 	initialState: S
 	saveDebounceTime?: number

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

@@ -3,9 +3,9 @@ import {debounce} from "@e280/stz"
 
 import {Trunk} from "../trunk.js"
 import {localPersistence} from "../persistence.js"
-import {Treestate, SetupOptions} from "../types.js"
+import {SetupOptions, Trunkstate} from "../types.js"
 
-export async function trunkSetup<S extends Treestate>(options: SetupOptions<S>) {
+export async function trunkSetup<S extends Trunkstate>(options: SetupOptions<S>) {
 	const {
 		version,
 		initialState,
@@ -23,14 +23,14 @@ export async function trunkSetup<S extends Treestate>(options: SetupOptions<S>)
 
 	const save = debounce(saveDebounceTime, async() => persistence.store.set({
 		version,
-		state: trunk.state,
+		state: trunk.state as any,
 	}))
 
 	// persistence: initial load from store
 	await load()
 
 	// persistence: save to store
-	trunk.watch(save)
+	trunk.on(save)
 
 	// cross-tab sync
 	const dispose = persistence.onChange(load)

package/s/tree/tree.test.ts

@@ -1,152 +1,161 @@
 
+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({
-	"strata": Science.suite({
+	"trunk": Science.suite({
 		"get state": Science.test(async() => {
-			const strata = new Trunk({count: 0})
-			expect(strata.state.count).is(0)
+			const trunk = new Trunk({count: 0})
+			expect(trunk.state.count).is(0)
 		}),
 
 		"state is immutable": Science.test(async() => {
-			const strata = new Trunk({count: 0})
-			expect(() => strata.state.count++).throws()
+			const trunk = new Trunk({count: 0})
+			expect(() => (trunk.state as any).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)
+			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 strata = new Trunk({count: 0})
+			const trunk = new Trunk({count: 0})
 			await expect(async() => {
 				let promise!: Promise<any>
-				await strata.mutate(() => {
-					promise = strata.mutate(() => {})
+				await trunk.mutate(() => {
+					promise = trunk.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()
+			const trunk = new Trunk({x: 1})
+			await trunk.mutate(s => { s.x = 2 })
+			expect(() => (trunk.state as any).x = 3).throws()
 		}),
 
-		"watch is published": Science.test(async() => {
-			const strata = new Trunk({count: 0})
+		"effect reacts to trunk mutation": Science.test(async() => {
+			const trunk = new Trunk({count: 0})
+			await nap(10)
 			let mutationCount = 0
-			strata.watch.sub(() => {mutationCount++})
-			await strata.mutate(state => state.count++)
+			effect(() => {
+				void trunk.state.count
+				mutationCount++
+			})
 			expect(mutationCount).is(1)
+			await trunk.mutate(state => state.count++)
+			expect(mutationCount).is(2)
 		}),
 
-		"watch is debounced": Science.test(async() => {
-			const strata = new Trunk({count: 0})
+		"signal.on is debounced": Science.test(async() => {
+			const trunk = new Trunk({count: 0})
 			let mutationCount = 0
-			strata.watch.sub(() => {mutationCount++})
-			const promise = strata.mutate(state => state.count++)
+			trunk.on.sub(() => {mutationCount++})
+			const promise = trunk.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"]})
+		"listeners are fired when array item is pushed": Science.test(async() => {
+			const trunk = new Trunk({items: ["hello", "world"]})
 			let mutationCount = 0
-			strata.watch.sub(() => {mutationCount++})
-			await strata.mutate(state => state.items.push("lol"))
+			trunk.on.sub(() => {mutationCount++})
+			await trunk.mutate(state => state.items.push("lol"))
 			expect(mutationCount).is(1)
-			expect(strata.state.items.length).is(3)
+			expect(trunk.state.items.length).is(3)
 		}),
 
 		"prevent mutation loops": Science.test(async() => {
-			const strata = new Trunk({count: 0})
+			const trunk = new Trunk({count: 0})
 			let mutationCount = 0
-			strata.watch.sub(async() => {
+			trunk.on.sub(async() => {
 				mutationCount++
 				if (mutationCount > 100)
 					return
-				await strata.mutate(s => s.count++)
+				await trunk.mutate(s => s.count++)
 			})
 			await expect(async() => {
-				await strata.mutate(state => state.count++)
+				await trunk.mutate(state => state.count++)
 			}).throwsAsync()
 			expect(mutationCount).is(1)
 		}),
 	}),
 
-	"substrata": Science.suite({
+	"branch": 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)
+			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 strata = new Trunk({
+			const trunk = new Trunk({
 				a: {b: 0}  as (null | {b: number}),
 			})
-			const a = strata.branch(s => s.a)
-			expect(strata.state.a?.b).is(0)
+			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(strata.state.a?.b).is(1)
+			expect(trunk.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)
+			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 strata = new Trunk({a: {b: {c: 0}}})
-			const a = strata.branch(s => s.a)
+			const trunk = new Trunk({a: {b: {c: 0}}})
+			const a = trunk.branch(s => s.a)
 			const b = a.branch(s => s.b)
-			expect(strata.state.a.b.c).is(0)
+			expect(trunk.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 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(strata.state.a.b.c).is(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(strata.state.a.b.c).is(102)
+			expect(trunk.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)
+			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)
 		}),
 
-		"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)
+		"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.watch.sub(() => {counted++})
+			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 strata = new Trunk({a: {b: 0}})
-			const a = strata.branch(s => s.a)
+			const trunk = new Trunk({a: {b: 0}})
+			const a = trunk.branch(s => s.a)
 			await expect(async() => {
 				let promise!: Promise<any>
-				await strata.mutate(() => {
+				await trunk.mutate(() => {
 					promise = a.mutate(() => {})
 				})
 				await promise
@@ -154,25 +163,25 @@ export default Science.suite({
 		}),
 
 		"forbid mutation in submutation": Science.test(async() => {
-			const strata = new Trunk({a: {b: 0}})
-			const a = strata.branch(s => s.a)
+			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 = strata.mutate(() => {})
+					promise = trunk.mutate(() => {})
 				})
 				await promise
 			}).throwsAsync()
 		}),
 	}),
 
-	"chronstrata": (() => {
+	"chronobranch": (() => {
 		const setup = () => {
-			const strata = new Trunk({
+			const trunk = new Trunk({
 				chron: Trunk.chronicle({count: 0}),
 			})
-			const chron = strata.chronobranch(64, s => s.chron)
-			return {strata, chron}
+			const chron = trunk.chronobranch(64, s => s.chron)
+			return {trunk, chron}
 		}
 
 		return Science.suite({

package/x/signals/index.d.ts

@@ -1,3 +1,4 @@
-export * from "./parts/computed.js";
+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

@@ -1,4 +1,5 @@
-export * from "./parts/computed.js";
+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

@@ -1 +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"}
+{"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

@@ -1,5 +1,5 @@
-export declare function effect<C = void>(collector: () => C, responder?: () => void): () => void;
-export declare function initEffect<C = void>(collector: () => C, responder?: () => void): {
+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

@@ -1,9 +1,9 @@
 import { debounce } from "@e280/stz";
 import { tracker } from "../../tracker/tracker.js";
 export function effect(collector, responder = collector) {
-    return initEffect(collector, responder).dispose;
+    return collectorEffect(collector, responder).dispose;
 }
-export function initEffect(collector, responder = collector) {
+export function collectorEffect(collector, responder = collector) {
     const { seen, result } = tracker.seen(collector);
     const fn = debounce(0, responder);
     const disposers = [];

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

@@ -1 +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"}
+{"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"}