@zeix/cause-effect 0.17.1 → 0.17.3

package/archive/list.ts

@@ -7,16 +7,10 @@ import {
 } from '../src/errors'
 import { isMutableSignal, type MutableSignal } from '../src/signal'
 import {
-	batchSignalWrites,
-	type Cleanup,
-	createWatcher,
-	emitNotification,
-	type Listener,
-	type Listeners,
-	type Notifications,
+	batch,
 	notifyWatchers,
 	subscribeActiveWatcher,
-	trackSignalReads,
+	UNSET,
 	type Watcher,
 } from '../src/system'
 import {
@@ -26,7 +20,6 @@ import {
 	isRecord,
 	isString,
 	isSymbol,
-	UNSET,
 } from '../src/util'
 import {
 	type Collection,
@@ -63,7 +56,6 @@ type List<T extends {}> = {
 	update(fn: (value: T) => T): void
 	sort<U = T>(compareFn?: (a: U, b: U) => number): void
 	splice(start: number, deleteCount?: number, ...items: T[]): T[]
-	on<K extends keyof Notifications>(type: K, listener: Listener<K>): Cleanup
 	remove(index: number): void
 }
 
@@ -90,12 +82,6 @@ const createList = <T extends {}>(
 	if (initialValue == null) throw new NullishSignalValueError('store')
 
 	const watchers = new Set<Watcher>()
-	const listeners: Listeners = {
-		add: new Set<Listener<'add'>>(),
-		change: new Set<Listener<'change'>>(),
-		remove: new Set<Listener<'remove'>>(),
-		sort: new Set<Listener<'sort'>>(),
-	}
 	const signals = new Map<string, MutableSignal<T>>()
 	const ownWatchers = new Map<string, Watcher>()
 
@@ -158,17 +144,6 @@ const createList = <T extends {}>(
 		return true
 	}
 
-	// Add own watcher for nested signal
-	const addOwnWatcher = (key: string, signal: MutableSignal<T>) => {
-		const watcher = createWatcher(() => {
-			trackSignalReads(watcher, () => {
-				signal.get() // Subscribe to the signal
-				emitNotification(listeners.change, [key])
-			})
-		})
-		ownWatchers.set(key, watcher)
-	}
-
 	// Add nested signal and own watcher
 	const addProperty = <K extends keyof T & string>(
 		key: K,
@@ -190,12 +165,9 @@ const createList = <T extends {}>(
 		// @ts-expect-error ignore
 		signals.set(key, signal)
 		if (!order.includes(key)) order.push(key)
-		// @ts-expect-error ignore
-		if (listeners.change.size) addOwnWatcher(key, signal)
 
 		if (single) {
 			notifyWatchers(watchers)
-			emitNotification(listeners.add, [key])
 		}
 		return true
 	}
@@ -218,29 +190,21 @@ const createList = <T extends {}>(
 		if (single) {
 			order = order.filter(() => true) // Compact array
 			notifyWatchers(watchers)
-			emitNotification(listeners.remove, [key])
 		}
 	}
 
 	// Commit batched changes and emit notifications
-	const batchChanges = (changes: DiffResult, initialRun?: boolean) => {
+	const batchChanges = (changes: DiffResult) => {
 		// Additions
 		if (Object.keys(changes.add).length) {
 			for (const key in changes.add)
 				// @ts-expect-error ignore
 				addProperty(key, changes.add[key] as T, false)
-
-			// Queue initial additions event to allow listeners to be added first
-			if (initialRun)
-				setTimeout(() => {
-					emitNotification(listeners.add, Object.keys(changes.add))
-				}, 0)
-			else emitNotification(listeners.add, Object.keys(changes.add))
 		}
 
 		// Changes
 		if (Object.keys(changes.change).length) {
-			batchSignalWrites(() => {
+			batch(() => {
 				for (const key in changes.change) {
 					const value = changes.change[key] as T
 					if (!isValidValue(key, value)) continue
@@ -249,7 +213,6 @@ const createList = <T extends {}>(
 					if (isMutableSignal(signal)) signal.set(value)
 					else throw new ReadonlySignalError(key, value)
 				}
-				emitNotification(listeners.change, Object.keys(changes.change))
 			})
 		}
 
@@ -257,25 +220,17 @@ const createList = <T extends {}>(
 		if (Object.keys(changes.remove).length) {
 			for (const key in changes.remove) removeProperty(key)
 			order = order.filter(() => true)
-			emitNotification(listeners.remove, Object.keys(changes.remove))
 		}
 
 		return changes.changed
 	}
 
 	// Reconcile data and dispatch events
-	const reconcile = (
-		oldValue: T[],
-		newValue: T[],
-		initialRun?: boolean,
-	): boolean =>
-		batchChanges(
-			diff(arrayToRecord(oldValue), arrayToRecord(newValue)),
-			initialRun,
-		)
+	const reconcile = (oldValue: T[], newValue: T[]): boolean =>
+		batchChanges(diff(arrayToRecord(oldValue), arrayToRecord(newValue)))
 
 	// Initialize data
-	reconcile([] as T[], initialValue, true)
+	reconcile([] as T[], initialValue)
 
 	// Methods and Properties
 	const prototype: Record<PropertyKey, unknown> = {}
@@ -401,7 +356,6 @@ const createList = <T extends {}>(
 				if (!isEqual(newOrder, order)) {
 					order = newOrder
 					notifyWatchers(watchers)
-					emitNotification(listeners.sort, order)
 				}
 			},
 		},
@@ -472,28 +426,6 @@ const createList = <T extends {}>(
 				return Object.values(remove) as T[]
 			},
 		},
-		on: {
-			value: <K extends keyof Notifications>(
-				type: K,
-				listener: Listener<K>,
-			): Cleanup => {
-				listeners[type].add(listener)
-				if (type === 'change' && !ownWatchers.size) {
-					for (const [key, signal] of signals)
-						addOwnWatcher(key, signal)
-				}
-				return () => {
-					listeners[type].delete(listener)
-					if (type === 'change' && !listeners.change.size) {
-						if (ownWatchers.size) {
-							for (const watcher of ownWatchers.values())
-								watcher.stop()
-							ownWatchers.clear()
-						}
-					}
-				}
-			},
-		},
 	})
 
 	// Return proxy directly with integrated signal methods

package/archive/memo.ts

@@ -6,13 +6,13 @@ import {
 } from '../src/errors'
 import {
 	createWatcher,
-	flushPendingReactions,
+	flush,
 	notifyWatchers,
 	subscribeActiveWatcher,
-	trackSignalReads,
+	UNSET,
 	type Watcher,
 } from '../src/system'
-import { isObjectOfType, isSyncFunction, UNSET } from '../src/util'
+import { isObjectOfType, isSyncFunction } from '../src/util'
 
 /* === Types === */
 
@@ -53,15 +53,13 @@ const createMemo = <T extends {}>(
 	let computing = false
 
 	// Own watcher: called when notified from sources (push)
-	const watcher = createWatcher(() => {
-		dirty = true
-		if (watchers.size) notifyWatchers(watchers)
-		else watcher.stop()
-	})
-
-	// Called when requested by dependencies (pull)
-	const compute = () =>
-		trackSignalReads(watcher, () => {
+	const watcher = createWatcher(
+		() => {
+			dirty = true
+			if (watchers.size) notifyWatchers(watchers)
+			else watcher.stop()
+		},
+		() => {
 			if (computing) throw new CircularDependencyError('memo')
 			let result: T
 			computing = true
@@ -86,7 +84,8 @@ const createMemo = <T extends {}>(
 				dirty = false
 			}
 			computing = false
-		})
+		},
+	)
 
 	const memo: Record<PropertyKey, unknown> = {}
 	Object.defineProperties(memo, {
@@ -96,8 +95,9 @@ const createMemo = <T extends {}>(
 		get: {
 			value: (): T => {
 				subscribeActiveWatcher(watchers)
-				flushPendingReactions()
-				if (dirty) compute()
+				flush()
+
+				if (dirty) watcher.run()
 				if (error) throw error
 				return value
 			},

package/archive/state.ts

@@ -3,9 +3,10 @@ import { InvalidCallbackError, NullishSignalValueError } from '../src/errors'
 import {
 	notifyWatchers,
 	subscribeActiveWatcher,
+	UNSET,
 	type Watcher,
 } from '../src/system'
-import { isFunction, isObjectOfType, UNSET } from '../src/util'
+import { isFunction, isObjectOfType } from '../src/util'
 
 /* === Types === */
 

package/archive/store.ts

@@ -7,25 +7,13 @@ import {
 } from '../src/errors'
 import { isMutableSignal, type MutableSignal } from '../src/signal'
 import {
-	batchSignalWrites,
-	type Cleanup,
-	createWatcher,
-	emitNotification,
-	type Listener,
-	type Listeners,
-	type Notifications,
+	batch,
 	notifyWatchers,
 	subscribeActiveWatcher,
-	trackSignalReads,
+	UNSET,
 	type Watcher,
 } from '../src/system'
-import {
-	isFunction,
-	isObjectOfType,
-	isRecord,
-	isSymbol,
-	UNSET,
-} from '../src/util'
+import { isFunction, isObjectOfType, isRecord, isSymbol } from '../src/util'
 import { isComputed } from './computed'
 import { createList, isList, type List } from './list'
 import { createState, isState, type State } from './state'
@@ -62,7 +50,6 @@ type Store<T extends UnknownRecord> = {
 	sort<U = T[Extract<keyof T, string>]>(
 		compareFn?: (a: U, b: U) => number,
 	): void
-	on<K extends keyof Notifications>(type: K, listener: Listener<K>): Cleanup
 	remove<K extends Extract<keyof T, string>>(key: K): void
 }
 
@@ -92,11 +79,6 @@ const createStore = <T extends UnknownRecord>(initialValue: T): Store<T> => {
 	if (initialValue == null) throw new NullishSignalValueError('store')
 
 	const watchers = new Set<Watcher>()
-	const listeners: Omit<Listeners, 'sort'> = {
-		add: new Set<Listener<'add'>>(),
-		change: new Set<Listener<'change'>>(),
-		remove: new Set<Listener<'remove'>>(),
-	}
 	const signals = new Map<
 		string,
 		MutableSignal<T[Extract<keyof T, string>] & {}>
@@ -123,20 +105,6 @@ const createStore = <T extends UnknownRecord>(initialValue: T): Store<T> => {
 		return true
 	}
 
-	// Add own watcher for nested signal
-	const addOwnWatcher = <K extends keyof T & string>(
-		key: K,
-		signal: MutableSignal<T[K] & {}>,
-	) => {
-		const watcher = createWatcher(() => {
-			trackSignalReads(watcher, () => {
-				signal.get() // Subscribe to the signal
-				emitNotification(listeners.change, [key])
-			})
-		})
-		ownWatchers.set(key, watcher)
-	}
-
 	// Add nested signal and effect
 	const addProperty = <K extends keyof T & string>(
 		key: K,
@@ -159,11 +127,9 @@ const createStore = <T extends UnknownRecord>(initialValue: T): Store<T> => {
 		// Set internal states
 		// @ts-expect-error non-matching signal types
 		signals.set(key, signal)
-		if (listeners.change.size) addOwnWatcher(key, signal)
 
 		if (single) {
 			notifyWatchers(watchers)
-			emitNotification(listeners.add, [key])
 		}
 		return true
 	}
@@ -183,12 +149,11 @@ const createStore = <T extends UnknownRecord>(initialValue: T): Store<T> => {
 
 		if (single) {
 			notifyWatchers(watchers)
-			emitNotification(listeners.remove, [key])
 		}
 	}
 
 	// Commit batched changes and emit notifications
-	const batchChanges = (changes: DiffResult, initialRun?: boolean) => {
+	const batchChanges = (changes: DiffResult) => {
 		// Additions
 		if (Object.keys(changes.add).length) {
 			for (const key in changes.add)
@@ -197,18 +162,11 @@ const createStore = <T extends UnknownRecord>(initialValue: T): Store<T> => {
 					changes.add[key] as T[Extract<keyof T, string>] & {},
 					false,
 				)
-
-			// Queue initial additions event to allow listeners to be added first
-			if (initialRun)
-				setTimeout(() => {
-					emitNotification(listeners.add, Object.keys(changes.add))
-				}, 0)
-			else emitNotification(listeners.add, Object.keys(changes.add))
 		}
 
 		// Changes
 		if (Object.keys(changes.change).length) {
-			batchSignalWrites(() => {
+			batch(() => {
 				for (const key in changes.change) {
 					const value = changes.change[key] as T[Extract<
 						keyof T,
@@ -220,28 +178,23 @@ const createStore = <T extends UnknownRecord>(initialValue: T): Store<T> => {
 					if (isMutableSignal(signal)) signal.set(value)
 					else throw new ReadonlySignalError(key, value)
 				}
-				emitNotification(listeners.change, Object.keys(changes.change))
 			})
 		}
 
 		// Removals
 		if (Object.keys(changes.remove).length) {
 			for (const key in changes.remove) removeProperty(key)
-			emitNotification(listeners.remove, Object.keys(changes.remove))
 		}
 
 		return changes.changed
 	}
 
 	// Reconcile data and dispatch events
-	const reconcile = (
-		oldValue: T,
-		newValue: T,
-		initialRun?: boolean,
-	): boolean => batchChanges(diff(oldValue, newValue), initialRun)
+	const reconcile = (oldValue: T, newValue: T): boolean =>
+		batchChanges(diff(oldValue, newValue))
 
 	// Initialize data
-	reconcile({} as T, initialValue, true)
+	reconcile({} as T, initialValue)
 
 	// Methods and Properties
 	const prototype: Record<PropertyKey, unknown> = {}
@@ -295,29 +248,6 @@ const createStore = <T extends UnknownRecord>(initialValue: T): Store<T> => {
 				store.set(fn(current()))
 			},
 		},
-		on: {
-			value: <K extends keyof Omit<Listeners, 'sort'>>(
-				type: K,
-				listener: Listener<K>,
-			): Cleanup => {
-				listeners[type].add(listener)
-				if (type === 'change' && !ownWatchers.size) {
-					for (const [key, signal] of signals)
-						// @ts-expect-error ignore
-						addOwnWatcher(key, signal)
-				}
-				return () => {
-					listeners[type].delete(listener)
-					if (type === 'change' && !listeners.change.size) {
-						if (ownWatchers.size) {
-							for (const watcher of ownWatchers.values())
-								watcher.stop()
-							ownWatchers.clear()
-						}
-					}
-				}
-			},
-		},
 	})
 
 	// Return proxy directly with integrated signal methods

package/archive/task.ts

@@ -7,18 +7,13 @@ import {
 } from '../src/errors'
 import {
 	createWatcher,
-	flushPendingReactions,
+	flush,
 	notifyWatchers,
 	subscribeActiveWatcher,
-	trackSignalReads,
+	UNSET,
 	type Watcher,
 } from '../src/system'
-import {
-	isAbortError,
-	isAsyncFunction,
-	isObjectOfType,
-	UNSET,
-} from '../src/util'
+import { isAbortError, isAsyncFunction, isObjectOfType } from '../src/util'
 
 /* === Types === */
 
@@ -96,19 +91,14 @@ const createTask = <T extends {}>(
 		}
 
 	// Own watcher: called when notified from sources (push)
-	const watcher = createWatcher(() => {
-		dirty = true
-		controller?.abort()
-		if (watchers.size) notifyWatchers(watchers)
-		else watcher.stop()
-	})
-	watcher.onCleanup(() => {
-		controller?.abort()
-	})
-
-	// Called when requested by dependencies (pull)
-	const compute = () =>
-		trackSignalReads(watcher, () => {
+	const watcher = createWatcher(
+		() => {
+			dirty = true
+			controller?.abort()
+			if (watchers.size) notifyWatchers(watchers)
+			else watcher.stop()
+		},
+		() => {
 			if (computing) throw new CircularDependencyError('computed')
 			changed = false
 			// Return current value until promise resolves
@@ -120,7 +110,7 @@ const createTask = <T extends {}>(
 				() => {
 					computing = false
 					controller = undefined
-					compute() // Retry computation with updated state
+					watcher.run() // Retry computation with updated state
 				},
 				{
 					once: true,
@@ -141,7 +131,11 @@ const createTask = <T extends {}>(
 			else if (null == result || UNSET === result) nil()
 			else ok(result)
 			computing = false
-		})
+		},
+	)
+	watcher.onCleanup(() => {
+		controller?.abort()
+	})
 
 	const task: Record<PropertyKey, unknown> = {}
 	Object.defineProperties(task, {
@@ -151,8 +145,9 @@ const createTask = <T extends {}>(
 		get: {
 			value: (): T => {
 				subscribeActiveWatcher(watchers)
-				flushPendingReactions()
-				if (dirty) compute()
+				flush()
+
+				if (dirty) watcher.run()
 				if (error) throw error
 				return value
 			},