@zeix/cause-effect 0.17.1 → 0.17.3

package/src/classes/store.ts

@@ -1,16 +1,20 @@
-import { diff, type UnknownRecord } from '../diff'
-import { DuplicateKeyError, validateSignalValue } from '../errors'
-import { createMutableSignal, type MutableSignal, type Signal } from '../signal'
+import { type DiffResult, diff, type UnknownRecord } from '../diff'
 import {
-	type Cleanup,
-	type Listener,
-	type Listeners,
-	notifyWatchers,
-	subscribeActiveWatcher,
-	type Watcher,
+	DuplicateKeyError,
+	guardMutableSignal,
+	validateSignalValue,
+} from '../errors'
+import { createMutableSignal, type MutableSignal } from '../signal'
+import {
+	batch,
+	notifyOf,
+	registerWatchCallbacks,
+	type SignalOptions,
+	subscribeTo,
+	UNSET,
+	unsubscribeAllFrom,
 } from '../system'
-import { isFunction, isObjectOfType, isRecord, isSymbol, UNSET } from '../util'
-import { Composite } from './composite'
+import { isFunction, isObjectOfType, isRecord, isSymbol } from '../util'
 import type { List } from './list'
 import type { State } from './state'
 
@@ -30,40 +34,93 @@ const TYPE_STORE = 'Store' as const
 
 /* === Store Implementation === */
 
+/**
+ * Create a new store with the given initial value.
+ *
+ * @since 0.17.0
+ * @param {T} initialValue - The initial value of the store
+ * @throws {NullishSignalValueError} - If the initial value is null or undefined
+ * @throws {InvalidSignalValueError} - If the initial value is not an object
+ */
 class BaseStore<T extends UnknownRecord> {
-	#composite: Composite<T, Signal<T[keyof T] & {}>>
-	#watchers = new Set<Watcher>()
-
-	/**
-	 * Create a new store with the given initial value.
-	 *
-	 * @param {T} initialValue - The initial value of the store
-	 * @throws {NullishSignalValueError} - If the initial value is null or undefined
-	 * @throws {InvalidSignalValueError} - If the initial value is not an object
-	 */
-	constructor(initialValue: T) {
-		validateSignalValue('store', initialValue, isRecord)
-
-		this.#composite = new Composite<T, Signal<T[keyof T] & {}>>(
+	#signals = new Map<keyof T & string, MutableSignal<T[keyof T] & {}>>()
+
+	constructor(initialValue: T, options?: SignalOptions<T>) {
+		validateSignalValue(
+			TYPE_STORE,
 			initialValue,
-			<K extends keyof T & string>(
-				key: K,
-				value: unknown,
-			): value is T[K] & {} => {
-				validateSignalValue(`store for key "${key}"`, value)
-				return true
-			},
-			value => createMutableSignal(value),
+			options?.guard ?? isRecord,
 		)
+
+		this.#change({
+			add: initialValue,
+			change: {},
+			remove: {},
+			changed: true,
+		})
+		if (options?.watched)
+			registerWatchCallbacks(this, options.watched, options.unwatched)
 	}
 
 	get #value(): T {
 		const record = {} as UnknownRecord
-		for (const [key, signal] of this.#composite.signals.entries())
+		for (const [key, signal] of this.#signals.entries())
 			record[key] = signal.get()
 		return record as T
 	}
 
+	#validate<K extends keyof T & string>(
+		key: K,
+		value: unknown,
+	): value is T[K] & {} {
+		validateSignalValue(`${TYPE_STORE} for key "${key}"`, value)
+		return true
+	}
+
+	#add<K extends keyof T & string>(key: K, value: T[K]): boolean {
+		if (!this.#validate(key, value)) return false
+
+		this.#signals.set(
+			key,
+			createMutableSignal(value) as unknown as MutableSignal<
+				T[keyof T] & {}
+			>,
+		)
+		return true
+	}
+
+	#change(changes: DiffResult): boolean {
+		// Additions
+		if (Object.keys(changes.add).length) {
+			for (const key in changes.add)
+				this.#add(
+					key,
+					changes.add[key] as T[Extract<keyof T, string>] & {},
+				)
+		}
+
+		// Changes
+		if (Object.keys(changes.change).length) {
+			batch(() => {
+				for (const key in changes.change) {
+					const value = changes.change[key]
+					if (!this.#validate(key, value)) continue
+
+					const signal = this.#signals.get(key)
+					if (guardMutableSignal(`list item "${key}"`, value, signal))
+						signal.set(value)
+				}
+			})
+		}
+
+		// Removals
+		if (Object.keys(changes.remove).length) {
+			for (const key in changes.remove) this.remove(key)
+		}
+
+		return changes.changed
+	}
+
 	// Public methods
 	get [Symbol.toStringTag](): 'Store' {
 		return TYPE_STORE
@@ -76,30 +133,12 @@ class BaseStore<T extends UnknownRecord> {
 	*[Symbol.iterator](): IterableIterator<
 		[string, MutableSignal<T[keyof T] & {}>]
 	> {
-		for (const [key, signal] of this.#composite.signals.entries())
-			yield [key, signal as MutableSignal<T[keyof T] & {}>]
-	}
-
-	get(): T {
-		subscribeActiveWatcher(this.#watchers)
-		return this.#value
-	}
-
-	set(newValue: T): void {
-		if (UNSET === newValue) {
-			this.#composite.clear()
-			notifyWatchers(this.#watchers)
-			this.#watchers.clear()
-			return
-		}
-
-		const oldValue = this.#value
-		const changed = this.#composite.change(diff(oldValue, newValue))
-		if (changed) notifyWatchers(this.#watchers)
+		for (const [key, signal] of this.#signals.entries()) yield [key, signal]
 	}
 
 	keys(): IterableIterator<string> {
-		return this.#composite.signals.keys()
+		subscribeTo(this)
+		return this.#signals.keys()
 	}
 
 	byKey<K extends keyof T & string>(
@@ -111,9 +150,8 @@ class BaseStore<T extends UnknownRecord> {
 			: T[K] extends unknown & {}
 				? State<T[K] & {}>
 				: State<T[K] & {}> | undefined {
-		return this.#composite.signals.get(
-			key,
-		) as T[K] extends readonly (infer U extends {})[]
+		return this.#signals.get(key) as T[K] extends readonly (infer U extends
+			{})[]
 			? List<U>
 			: T[K] extends UnknownRecord
 				? Store<T[K]>
@@ -122,29 +160,39 @@ class BaseStore<T extends UnknownRecord> {
 					: State<T[K] & {}> | undefined
 	}
 
+	get(): T {
+		subscribeTo(this)
+		return this.#value
+	}
+
+	set(newValue: T): void {
+		if (UNSET === newValue) {
+			this.#signals.clear()
+			notifyOf(this)
+			unsubscribeAllFrom(this)
+			return
+		}
+
+		const changed = this.#change(diff(this.#value, newValue))
+		if (changed) notifyOf(this)
+	}
+
 	update(fn: (oldValue: T) => T): void {
 		this.set(fn(this.get()))
 	}
 
 	add<K extends keyof T & string>(key: K, value: T[K]): K {
-		if (this.#composite.signals.has(key))
-			throw new DuplicateKeyError('store', key, value)
+		if (this.#signals.has(key))
+			throw new DuplicateKeyError(TYPE_STORE, key, value)
 
-		const ok = this.#composite.add(key, value)
-		if (ok) notifyWatchers(this.#watchers)
+		const ok = this.#add(key, value)
+		if (ok) notifyOf(this)
 		return key
 	}
 
 	remove(key: string): void {
-		const ok = this.#composite.remove(key)
-		if (ok) notifyWatchers(this.#watchers)
-	}
-
-	on<K extends keyof Omit<Listeners, 'sort'>>(
-		type: K,
-		listener: Listener<K>,
-	): Cleanup {
-		return this.#composite.on(type, listener)
+		const ok = this.#signals.delete(key)
+		if (ok) notifyOf(this)
 	}
 }
 
@@ -155,10 +203,14 @@ class BaseStore<T extends UnknownRecord> {
  *
  * @since 0.15.0
  * @param {T} initialValue - Initial object or array value of the store
+ * @param {SignalOptions<T>} options - Options for the store
  * @returns {Store<T>} - New store with reactive properties that preserves the original type T
  */
-const createStore = <T extends UnknownRecord>(initialValue: T): Store<T> => {
-	const instance = new BaseStore(initialValue)
+const createStore = <T extends UnknownRecord>(
+	initialValue: T,
+	options?: SignalOptions<T>,
+): Store<T> => {
+	const instance = new BaseStore(initialValue, options)
 
 	// Return proxy for property access
 	return new Proxy(instance, {

package/src/diff.ts

@@ -1,5 +1,6 @@
 import { CircularDependencyError } from './errors'
-import { isNonNullObject, isRecord, isRecordOrArray, UNSET } from './util'
+import { UNSET } from './system'
+import { isNonNullObject, isRecord, isRecordOrArray } from './util'
 
 /* === Types === */
 

package/src/effect.ts

@@ -1,12 +1,9 @@
 import { CircularDependencyError, InvalidCallbackError } from './errors'
-import { type Cleanup, createWatcher, trackSignalReads } from './system'
+import { type Cleanup, createWatcher, type MaybeCleanup } from './system'
 import { isAbortError, isAsyncFunction, isFunction } from './util'
 
 /* === Types === */
 
-// biome-ignore lint/suspicious/noConfusingVoidType: optional Cleanup return type
-type MaybeCleanup = Cleanup | undefined | void
-
 type EffectCallback =
 	| (() => MaybeCleanup)
 	| ((abort: AbortSignal) => Promise<MaybeCleanup>)
@@ -32,8 +29,11 @@ const createEffect = (callback: EffectCallback): Cleanup => {
 	let running = false
 	let controller: AbortController | undefined
 
-	const watcher = createWatcher(() =>
-		trackSignalReads(watcher, () => {
+	const watcher = createWatcher(
+		() => {
+			watcher.run()
+		},
+		() => {
 			if (running) throw new CircularDependencyError('effect')
 			running = true
 
@@ -59,7 +59,10 @@ const createEffect = (callback: EffectCallback): Cleanup => {
 						})
 						.catch(error => {
 							if (!isAbortError(error))
-								console.error('Async effect error:', error)
+								console.error(
+									'Error in async effect callback:',
+									error,
+								)
 						})
 				} else {
 					cleanup = callback()
@@ -67,17 +70,21 @@ const createEffect = (callback: EffectCallback): Cleanup => {
 				}
 			} catch (error) {
 				if (!isAbortError(error))
-					console.error('Effect callback error:', error)
+					console.error('Error in effect callback:', error)
 			}
 
 			running = false
-		}),
+		},
 	)
 
 	watcher()
 	return () => {
 		controller?.abort()
-		watcher.stop()
+		try {
+			watcher.stop()
+		} catch (error) {
+			console.error('Error in effect cleanup:', error)
+		}
 	}
 }
 

package/src/errors.ts

@@ -1,5 +1,6 @@
 import { isMutableSignal, type MutableSignal } from './signal'
-import { isFunction, isSymbol, UNSET, valueString } from './util'
+import { UNSET } from './system'
+import { isFunction, isSymbol, valueString } from './util'
 
 /* === Types === */
 
@@ -25,6 +26,13 @@ class DuplicateKeyError extends Error {
 	}
 }
 
+class FailedAssertionError extends Error {
+	constructor(message: string = 'unexpected condition') {
+		super(`Assertion failed: ${message}`)
+		this.name = 'FailedAssertionError'
+	}
+}
+
 class InvalidCallbackError extends TypeError {
 	constructor(where: string, value: unknown) {
 		super(`Invalid ${where} callback ${valueString(value)}`)
@@ -64,6 +72,10 @@ class ReadonlySignalError extends Error {
 
 /* === Functions === */
 
+function assert(condition: unknown, msg?: string): asserts condition {
+	if (!condition) throw new FailedAssertionError(msg)
+}
+
 const createError = /*#__PURE__*/ (reason: unknown): Error =>
 	reason instanceof Error ? reason : Error(String(reason))
 
@@ -103,6 +115,7 @@ export {
 	InvalidSignalValueError,
 	NullishSignalValueError,
 	ReadonlySignalError,
+	assert,
 	createError,
 	validateCallback,
 	validateSignalValue,

package/src/resolve.ts

@@ -1,7 +1,7 @@
 import type { UnknownRecord } from './diff'
 import { createError } from './errors'
 import type { SignalValues, UnknownSignalRecord } from './signal'
-import { UNSET } from './util'
+import { UNSET } from './system'
 
 /* === Types === */
 

package/src/signal.ts

@@ -10,7 +10,6 @@ import { isList, List } from './classes/list'
 import { isState, State } from './classes/state'
 import { createStore, isStore, type Store } from './classes/store'
 import type { UnknownRecord } from './diff'
-// import type { Collection } from './signals/collection'
 import { isRecord, isUniformArray } from './util'
 
 /* === Types === */
@@ -19,6 +18,7 @@ type Signal<T extends {}> = {
 	get(): T
 }
 
+type UnknownSignal = Signal<unknown & {}>
 type MutableSignal<T extends {}> = T extends readonly (infer U extends {})[]
 	? List<U>
 	: T extends UnknownRecord
@@ -26,7 +26,7 @@ type MutableSignal<T extends {}> = T extends readonly (infer U extends {})[]
 		: State<T>
 type ReadonlySignal<T extends {}> = Computed<T> // | Collection<T>
 
-type UnknownSignalRecord = Record<string, Signal<unknown & {}>>
+type UnknownSignalRecord = Record<string, UnknownSignal>
 
 type SignalValues<S extends UnknownSignalRecord> = {
 	[K in keyof S]: S[K] extends Signal<infer T> ? T : never
@@ -101,5 +101,6 @@ export {
 	type ReadonlySignal,
 	type Signal,
 	type SignalValues,
+	type UnknownSignal,
 	type UnknownSignalRecord,
 }