@zeix/cause-effect 0.17.2 → 0.17.3

package/src/classes/store.ts

@@ -1,26 +1,20 @@
-import { diff, type UnknownRecord } from '../diff'
+import { type DiffResult, diff, type UnknownRecord } from '../diff'
 import {
 	DuplicateKeyError,
-	InvalidHookError,
+	guardMutableSignal,
 	validateSignalValue,
 } from '../errors'
-import { createMutableSignal, type MutableSignal, type Signal } from '../signal'
+import { createMutableSignal, type MutableSignal } from '../signal'
 import {
-	type Cleanup,
-	HOOK_ADD,
-	HOOK_CHANGE,
-	HOOK_REMOVE,
-	HOOK_WATCH,
-	type Hook,
-	type HookCallback,
-	isHandledHook,
-	notifyWatchers,
-	subscribeActiveWatcher,
+	batch,
+	notifyOf,
+	registerWatchCallbacks,
+	type SignalOptions,
+	subscribeTo,
 	UNSET,
-	type Watcher,
+	unsubscribeAllFrom,
 } from '../system'
 import { isFunction, isObjectOfType, isRecord, isSymbol } from '../util'
-import { Composite } from './composite'
 import type { List } from './list'
 import type { State } from './state'
 
@@ -40,41 +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>()
-	#watchHookCallbacks: Set<HookCallback> | undefined
-
-	/**
-	 * 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(TYPE_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(`${TYPE_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
@@ -87,12 +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] & {}>]
+		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>(
@@ -104,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]>
@@ -116,21 +161,20 @@ class BaseStore<T extends UnknownRecord> {
 	}
 
 	get(): T {
-		subscribeActiveWatcher(this.#watchers, this.#watchHookCallbacks)
+		subscribeTo(this)
 		return this.#value
 	}
 
 	set(newValue: T): void {
 		if (UNSET === newValue) {
-			this.#composite.clear()
-			notifyWatchers(this.#watchers)
-			this.#watchers.clear()
+			this.#signals.clear()
+			notifyOf(this)
+			unsubscribeAllFrom(this)
 			return
 		}
 
-		const oldValue = this.#value
-		const changed = this.#composite.change(diff(oldValue, newValue))
-		if (changed) notifyWatchers(this.#watchers)
+		const changed = this.#change(diff(this.#value, newValue))
+		if (changed) notifyOf(this)
 	}
 
 	update(fn: (oldValue: T) => T): void {
@@ -138,30 +182,17 @@ class BaseStore<T extends UnknownRecord> {
 	}
 
 	add<K extends keyof T & string>(key: K, value: T[K]): K {
-		if (this.#composite.signals.has(key))
+		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(type: Hook, callback: HookCallback): Cleanup {
-		if (type === HOOK_WATCH) {
-			this.#watchHookCallbacks ||= new Set<HookCallback>()
-			this.#watchHookCallbacks.add(callback)
-			return () => {
-				this.#watchHookCallbacks?.delete(callback)
-			}
-		} else if (isHandledHook(type, [HOOK_ADD, HOOK_CHANGE, HOOK_REMOVE])) {
-			return this.#composite.on(type, callback)
-		}
-		throw new InvalidHookError(TYPE_STORE, type)
+		const ok = this.#signals.delete(key)
+		if (ok) notifyOf(this)
 	}
 }
 
@@ -172,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/effect.ts

@@ -1,11 +1,5 @@
 import { CircularDependencyError, InvalidCallbackError } from './errors'
-import {
-	type Cleanup,
-	createWatcher,
-	HOOK_CLEANUP,
-	type MaybeCleanup,
-	trackSignalReads,
-} from './system'
+import { type Cleanup, createWatcher, type MaybeCleanup } from './system'
 import { isAbortError, isAsyncFunction, isFunction } from './util'
 
 /* === Types === */
@@ -35,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
 
@@ -58,7 +55,7 @@ const createEffect = (callback: EffectCallback): Cleanup => {
 								isFunction(cleanup) &&
 								controller === currentController
 							)
-								watcher.on(HOOK_CLEANUP, cleanup)
+								watcher.onCleanup(cleanup)
 						})
 						.catch(error => {
 							if (!isAbortError(error))
@@ -69,7 +66,7 @@ const createEffect = (callback: EffectCallback): Cleanup => {
 						})
 				} else {
 					cleanup = callback()
-					if (isFunction(cleanup)) watcher.on(HOOK_CLEANUP, cleanup)
+					if (isFunction(cleanup)) watcher.onCleanup(cleanup)
 				}
 			} catch (error) {
 				if (!isAbortError(error))
@@ -77,7 +74,7 @@ const createEffect = (callback: EffectCallback): Cleanup => {
 			}
 
 			running = false
-		}),
+		},
 	)
 
 	watcher()

package/src/errors.ts

@@ -26,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)}`)
@@ -40,13 +47,6 @@ class InvalidCollectionSourceError extends TypeError {
 	}
 }
 
-class InvalidHookError extends TypeError {
-	constructor(where: string, type: string) {
-		super(`Invalid hook "${type}" in  ${where}`)
-		this.name = 'InvalidHookError'
-	}
-}
-
 class InvalidSignalValueError extends TypeError {
 	constructor(where: string, value: unknown) {
 		super(`Invalid signal value ${valueString(value)} in ${where}`)
@@ -72,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))
 
@@ -108,10 +112,10 @@ export {
 	DuplicateKeyError,
 	InvalidCallbackError,
 	InvalidCollectionSourceError,
-	InvalidHookError,
 	InvalidSignalValueError,
 	NullishSignalValueError,
 	ReadonlySignalError,
+	assert,
 	createError,
 	validateCallback,
 	validateSignalValue,

package/src/signal.ts

@@ -18,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
@@ -25,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
@@ -100,5 +101,6 @@ export {
 	type ReadonlySignal,
 	type Signal,
 	type SignalValues,
+	type UnknownSignal,
 	type UnknownSignalRecord,
 }