@zeix/cause-effect 0.15.2 → 0.16.1

package/src/store.ts

@@ -2,11 +2,10 @@ import { isComputed } from './computed'
 import {
 	type ArrayToRecord,
 	diff,
+	type PartialRecord,
 	type UnknownArray,
 	type UnknownRecord,
-	type UnknownRecordOrArray,
 } from './diff'
-import { effect } from './effect'
 import {
 	InvalidSignalValueError,
 	NullishSignalValueError,
@@ -14,15 +13,17 @@ import {
 	StoreKeyRangeError,
 	StoreKeyReadonlyError,
 } from './errors'
+import { isMutableSignal, type Signal } from './signal'
+import { createState, isState, type State } from './state'
 import {
 	batch,
 	type Cleanup,
+	createWatcher,
 	notify,
+	observe,
 	subscribe,
 	type Watcher,
-} from './scheduler'
-import { isMutableSignal, type Signal } from './signal'
-import { isState, type State, state } from './state'
+} from './system'
 import {
 	isFunction,
 	isObjectOfType,
@@ -37,51 +38,27 @@ import {
 
 type ArrayItem<T> = T extends readonly (infer U extends {})[] ? U : never
 
-type StoreEventMap<T extends UnknownRecord | UnknownArray> = {
-	'store-add': StoreAddEvent<T>
-	'store-change': StoreChangeEvent<T>
-	'store-remove': StoreRemoveEvent<T>
-	'store-sort': StoreSortEvent
+type StoreChanges<T> = {
+	add: PartialRecord<T>
+	change: PartialRecord<T>
+	remove: PartialRecord<T>
+	sort: string[]
 }
 
-interface StoreEventTarget<T extends UnknownRecord | UnknownArray>
-	extends EventTarget {
-	addEventListener<K extends keyof StoreEventMap<T>>(
-		type: K,
-		listener: (event: StoreEventMap<T>[K]) => void,
-		options?: boolean | AddEventListenerOptions,
-	): void
-
-	removeEventListener<K extends keyof StoreEventMap<T>>(
-		type: K,
-		listener: (event: StoreEventMap<T>[K]) => void,
-		options?: boolean | EventListenerOptions,
-	): void
-
-	dispatchEvent(event: Event): boolean
+type StoreListeners<T> = {
+	[K in keyof StoreChanges<T>]: Set<(change: StoreChanges<T>[K]) => void>
 }
 
-interface BaseStore<T extends UnknownRecord | UnknownArray>
-	extends StoreEventTarget<T> {
+interface BaseStore {
 	readonly [Symbol.toStringTag]: 'Store'
-	get(): T
-	set(value: T): void
-	update(fn: (value: T) => T): void
-	sort<
-		U = T extends UnknownArray ? ArrayItem<T> : T[Extract<keyof T, string>],
-	>(
-		compareFn?: (a: U, b: U) => number,
-	): void
-	readonly size: State<number>
+	readonly length: number
 }
 
-type RecordStore<T extends UnknownRecord> = BaseStore<T> & {
+type RecordStore<T extends UnknownRecord> = BaseStore & {
 	[K in keyof T]: T[K] extends readonly unknown[] | Record<string, unknown>
 		? Store<T[K]>
 		: State<T[K]>
 } & {
-	add<K extends Extract<keyof T, string>>(key: K, value: T[K]): void
-	remove<K extends Extract<keyof T, string>>(key: K): void
 	[Symbol.iterator](): IterableIterator<
 		[
 			Extract<keyof T, string>,
@@ -92,49 +69,45 @@ type RecordStore<T extends UnknownRecord> = BaseStore<T> & {
 				: State<T[Extract<keyof T, string>]>,
 		]
 	>
+	add<K extends Extract<keyof T, string>>(key: K, value: T[K]): void
+	get(): T
+	set(value: T): void
+	update(fn: (value: T) => T): void
+	sort<U = T[Extract<keyof T, string>]>(
+		compareFn?: (a: U, b: U) => number,
+	): void
+	on<K extends keyof StoreChanges<T>>(
+		type: K,
+		listener: (change: StoreChanges<T>[K]) => void,
+	): Cleanup
+	remove<K extends Extract<keyof T, string>>(key: K): void
 }
 
-type ArrayStore<T extends UnknownArray> = BaseStore<T> & {
-	readonly length: number
+type ArrayStore<T extends UnknownArray> = BaseStore & {
+	[Symbol.iterator](): IterableIterator<
+		ArrayItem<T> extends readonly unknown[] | Record<string, unknown>
+			? Store<ArrayItem<T>>
+			: State<ArrayItem<T>>
+	>
+	readonly [Symbol.isConcatSpreadable]: boolean
 	[n: number]: ArrayItem<T> extends
 		| readonly unknown[]
 		| Record<string, unknown>
 		? Store<ArrayItem<T>>
 		: State<ArrayItem<T>>
 	add(value: ArrayItem<T>): void
+	get(): T
+	set(value: T): void
+	update(fn: (value: T) => T): void
+	sort<U = ArrayItem<T>>(compareFn?: (a: U, b: U) => number): void
+	on<K extends keyof StoreChanges<T>>(
+		type: K,
+		listener: (change: StoreChanges<T>[K]) => void,
+	): Cleanup
 	remove(index: number): void
-	[Symbol.iterator](): IterableIterator<
-		ArrayItem<T> extends readonly unknown[] | Record<string, unknown>
-			? Store<ArrayItem<T>>
-			: State<ArrayItem<T>>
-	>
-	readonly [Symbol.isConcatSpreadable]: boolean
-}
-
-interface StoreAddEvent<T extends UnknownRecord | UnknownArray>
-	extends CustomEvent {
-	type: 'store-add'
-	detail: Partial<T>
-}
-
-interface StoreChangeEvent<T extends UnknownRecord | UnknownArray>
-	extends CustomEvent {
-	type: 'store-change'
-	detail: Partial<T>
-}
-
-interface StoreRemoveEvent<T extends UnknownRecord | UnknownArray>
-	extends CustomEvent {
-	type: 'store-remove'
-	detail: Partial<T>
 }
 
-interface StoreSortEvent extends CustomEvent {
-	type: 'store-sort'
-	detail: string[]
-}
-
-type Store<T> = T extends UnknownRecord
+type Store<T extends UnknownRecord | UnknownArray> = T extends UnknownRecord
 	? RecordStore<T>
 	: T extends UnknownArray
 		? ArrayStore<T>
@@ -144,11 +117,6 @@ type Store<T> = T extends UnknownRecord
 
 const TYPE_STORE = 'Store'
 
-const STORE_EVENT_ADD = 'store-add'
-const STORE_EVENT_CHANGE = 'store-change'
-const STORE_EVENT_REMOVE = 'store-remove'
-const STORE_EVENT_SORT = 'store-sort'
-
 /* === Functions === */
 
 /**
@@ -163,32 +131,39 @@ const STORE_EVENT_SORT = 'store-sort'
  * @param {T} initialValue - initial object or array value of the store
  * @returns {Store<T>} - new store with reactive properties that preserves the original type T
  */
-const store = <T extends UnknownRecord | UnknownArray>(
+const createStore = <T extends UnknownRecord | UnknownArray>(
 	initialValue: T,
 ): Store<T> => {
+	if (initialValue == null) throw new NullishSignalValueError('store')
+
 	const watchers = new Set<Watcher>()
-	const eventTarget = new EventTarget()
+	const listeners: StoreListeners<T> = {
+		add: new Set<(change: PartialRecord<T>) => void>(),
+		change: new Set<(change: PartialRecord<T>) => void>(),
+		remove: new Set<(change: PartialRecord<T>) => void>(),
+		sort: new Set<(change: string[]) => void>(),
+	}
 	const signals = new Map<string, Signal<T[Extract<keyof T, string>] & {}>>()
-	const cleanups = new Map<string, Cleanup>()
+	const signalWatchers = new Map<string, Watcher>()
 
 	// Determine if this is an array-like store at creation time
 	const isArrayLike = Array.isArray(initialValue)
 
-	// Internal state
-	const size = state(0)
-
 	// Get current record
 	const current = () => {
 		const record: Record<string, unknown> = {}
-		for (const [key, signal] of signals) {
-			record[key] = signal.get()
-		}
+		for (const [key, signal] of signals) record[key] = signal.get()
 		return record
 	}
 
-	// Emit event
-	const emit = <R>(type: keyof StoreEventMap<T>, detail: R) =>
-		eventTarget.dispatchEvent(new CustomEvent(type, { detail }))
+	// Emit change notifications
+	const emit = <K extends keyof StoreChanges<T>>(
+		key: K,
+		changes: StoreChanges<T>[K],
+	) => {
+		Object.freeze(changes)
+		for (const listener of listeners[key]) listener(changes)
+	}
 
 	// Get sorted indexes
 	const getSortedIndexes = () =>
@@ -214,59 +189,47 @@ const store = <T extends UnknownRecord | UnknownArray>(
 	}
 
 	// Add nested signal and effect
-	const addProperty = <K extends Extract<keyof T, string>>(
-		key: K,
-		value: T[K] | ArrayItem<T>,
+	const addProperty = (
+		key: string,
+		value: ArrayItem<T> | T[keyof T],
 		single = false,
 	): boolean => {
 		if (!isValidValue(key, value)) return false
 		const signal =
 			isState(value) || isStore(value)
 				? value
-				: isRecord(value)
-					? store(value)
-					: Array.isArray(value)
-						? store(value)
-						: state(value)
+				: isRecord(value) || Array.isArray(value)
+					? createStore(value)
+					: createState(value)
 		// @ts-expect-error non-matching signal types
 		signals.set(key, signal)
-		const cleanup = effect(() => {
-			const currentValue = signal.get()
-			if (currentValue != null)
-				emit(STORE_EVENT_CHANGE, {
-					[key]: currentValue,
-				} as unknown as Partial<T>)
-		})
-		cleanups.set(key, cleanup)
+		const watcher = createWatcher(() =>
+			observe(() => {
+				emit('change', { [key]: signal.get() } as PartialRecord<T>)
+			}, watcher),
+		)
+		watcher()
+		signalWatchers.set(key, watcher)
 
 		if (single) {
-			size.set(signals.size)
 			notify(watchers)
-			emit(STORE_EVENT_ADD, {
-				[key]: value,
-			} as unknown as Partial<T>)
+			emit('add', { [key]: value } as PartialRecord<T>)
 		}
 		return true
 	}
 
 	// Remove nested signal and effect
-	const removeProperty = <K extends Extract<keyof T, string>>(
-		key: K,
-		single = false,
-	) => {
+	const removeProperty = (key: string, single = false) => {
 		const ok = signals.delete(key)
 		if (ok) {
-			const cleanup = cleanups.get(key)
-			if (cleanup) cleanup()
-			cleanups.delete(key)
+			const watcher = signalWatchers.get(key)
+			if (watcher) watcher.cleanup()
+			signalWatchers.delete(key)
 		}
 
 		if (single) {
-			size.set(signals.size)
 			notify(watchers)
-			emit(STORE_EVENT_REMOVE, {
-				[key]: UNSET,
-			} as unknown as Partial<T>)
+			emit('remove', { [key]: UNSET } as PartialRecord<T>)
 		}
 		return ok
 	}
@@ -285,21 +248,16 @@ const store = <T extends UnknownRecord | UnknownArray>(
 		batch(() => {
 			// Additions
 			if (Object.keys(changes.add).length) {
-				for (const key in changes.add) {
-					const value = changes.add[key] ?? UNSET
-					addProperty(
-						key as Extract<keyof T, string>,
-						value as T[Extract<keyof T, string>] & {},
-					)
-				}
+				for (const key in changes.add)
+					addProperty(key, changes.add[key] ?? UNSET)
 
 				// Queue initial additions event to allow listeners to be added first
 				if (initialRun) {
 					setTimeout(() => {
-						emit(STORE_EVENT_ADD, changes.add as Partial<T>)
+						emit('add', changes.add)
 					}, 0)
 				} else {
-					emit<Partial<T>>(STORE_EVENT_ADD, changes.add as Partial<T>)
+					emit('add', changes.add)
 				}
 			}
 
@@ -309,206 +267,185 @@ const store = <T extends UnknownRecord | UnknownArray>(
 					const value = changes.change[key]
 					if (!isValidValue(key, value)) continue
 					const signal = signals.get(key as Extract<keyof T, string>)
-					if (isMutableSignal(signal))
-						signal.set(value as T[Extract<keyof T, string>] & {})
+					if (isMutableSignal(signal)) signal.set(value)
 					else
 						throw new StoreKeyReadonlyError(key, valueString(value))
 				}
-				emit(STORE_EVENT_CHANGE, changes.change as Partial<T>)
+				emit('change', changes.change)
 			}
 
 			// Removals
 			if (Object.keys(changes.remove).length) {
-				for (const key in changes.remove)
-					removeProperty(key as Extract<keyof T, string>)
-				emit(STORE_EVENT_REMOVE, changes.remove as Partial<T>)
+				for (const key in changes.remove) removeProperty(key)
+				emit('remove', changes.remove)
 			}
-
-			size.set(signals.size)
 		})
 
 		return changes.changed
 	}
 
-	// Initialize data - convert arrays to records for internal storage
+	// Initialize data
 	reconcile({} as T, initialValue, true)
 
 	// Methods and Properties
-	const s: Record<string, unknown> = {
-		add: isArrayLike
-			? (v: ArrayItem<T>): void => {
-					const nextIndex = signals.size
-					const key = String(nextIndex) as Extract<keyof T, string>
-					addProperty(key, v, true)
+	const store: Record<PropertyKey, unknown> = {}
+	Object.defineProperties(store, {
+		[Symbol.toStringTag]: {
+			value: TYPE_STORE,
+		},
+		[Symbol.isConcatSpreadable]: {
+			value: isArrayLike,
+		},
+		[Symbol.iterator]: {
+			value: isArrayLike
+				? function* () {
+						const indexes = getSortedIndexes()
+						for (const index of indexes) {
+							const signal = signals.get(String(index))
+							if (signal) yield signal
+						}
+					}
+				: function* () {
+						for (const [key, signal] of signals) yield [key, signal]
+					},
+		},
+		add: {
+			value: isArrayLike
+				? (v: ArrayItem<T>): void => {
+						addProperty(String(signals.size), v, true)
+					}
+				: <K extends Extract<keyof T, string>>(k: K, v: T[K]): void => {
+						if (!signals.has(k)) addProperty(k, v, true)
+						else throw new StoreKeyExistsError(k, valueString(v))
+					},
+		},
+		get: {
+			value: (): T => {
+				subscribe(watchers)
+				return recordToArray(current()) as T
+			},
+		},
+		remove: {
+			value: isArrayLike
+				? (index: number): void => {
+						const currentArray = recordToArray(current()) as T
+						const currentLength = signals.size
+						if (
+							!Array.isArray(currentArray) ||
+							index <= -currentLength ||
+							index >= currentLength
+						)
+							throw new StoreKeyRangeError(index)
+						const newArray = [...currentArray]
+						newArray.splice(index, 1)
+
+						if (reconcile(currentArray, newArray as unknown as T))
+							notify(watchers)
+					}
+				: (k: string): void => {
+						if (signals.has(k)) removeProperty(k, true)
+					},
+		},
+		set: {
+			value: (v: T): void => {
+				if (reconcile(current() as T, v)) {
+					notify(watchers)
+					if (UNSET === v) watchers.clear()
 				}
-			: <K extends Extract<keyof T, string>>(k: K, v: T[K]): void => {
-					if (!signals.has(k)) addProperty(k, v, true)
-					else throw new StoreKeyExistsError(k, valueString(v))
-				},
-		get: (): T => {
-			subscribe(watchers)
-			return recordToArray(current()) as T
+			},
 		},
-		remove: isArrayLike
-			? (index: number): void => {
-					const currentArray = recordToArray(current()) as T
-					const currentLength = signals.size
-					if (
-						!Array.isArray(currentArray) ||
-						index <= -currentLength ||
-						index >= currentLength
+		update: {
+			value: (fn: (v: T) => T): void => {
+				const oldValue = current()
+				const newValue = fn(recordToArray(oldValue) as T)
+				if (reconcile(oldValue as T, newValue)) {
+					notify(watchers)
+					if (UNSET === newValue) watchers.clear()
+				}
+			},
+		},
+		sort: {
+			value: (
+				compareFn?: <
+					U = T extends UnknownArray
+						? ArrayItem<T>
+						: T[Extract<keyof T, string>],
+				>(
+					a: U,
+					b: U,
+				) => number,
+			): void => {
+				// Get all entries as [key, value] pairs
+				const entries = Array.from(signals.entries())
+					.map(([key, signal]) => [key, signal.get()])
+					.sort(
+						compareFn
+							? (a, b) => compareFn(a[1], b[1])
+							: (a, b) =>
+									String(a[1]).localeCompare(String(b[1])),
 					)
-						throw new StoreKeyRangeError(index)
-					const newArray = [...currentArray]
-					newArray.splice(index, 1)
 
-					if (reconcile(currentArray, newArray as unknown as T))
-						notify(watchers)
-				}
-			: <K extends Extract<keyof T, string>>(k: K): void => {
-					if (signals.has(k)) removeProperty(k, true)
-				},
-		set: (v: T): void => {
-			if (reconcile(current() as T, v)) {
+				// Create array of original keys in their new sorted order
+				const newOrder: string[] = entries.map(([key]) => String(key))
+				const newSignals = new Map<
+					string,
+					Signal<T[Extract<keyof T, string>] & {}>
+				>()
+
+				entries.forEach(([key], newIndex) => {
+					const oldKey = String(key)
+					const newKey = isArrayLike ? String(newIndex) : String(key)
+					const signal = signals.get(oldKey)
+					if (signal) newSignals.set(newKey, signal)
+				})
+
+				// Replace signals map
+				signals.clear()
+				newSignals.forEach((signal, key) => signals.set(key, signal))
 				notify(watchers)
-				if (UNSET === v) watchers.clear()
-			}
+				emit('sort', newOrder)
+			},
 		},
-		update: (fn: (v: T) => T): void => {
-			const oldValue = current()
-			const newValue = fn(recordToArray(oldValue) as T)
-			if (reconcile(oldValue as T, newValue)) {
-				notify(watchers)
-				if (UNSET === newValue) watchers.clear()
-			}
+		on: {
+			value: <K extends keyof StoreChanges<T>>(
+				type: K,
+				listener: (change: StoreChanges<T>[K]) => void,
+			): Cleanup => {
+				listeners[type].add(listener)
+				return () => listeners[type].delete(listener)
+			},
 		},
-		sort: (
-			compareFn?: <
-				U = T extends UnknownArray
-					? ArrayItem<T>
-					: T[Extract<keyof T, string>],
-			>(
-				a: U,
-				b: U,
-			) => number,
-		): void => {
-			// Get all entries as [key, value] pairs
-			const entries = Array.from(signals.entries())
-				.map(
-					([key, signal]) =>
-						[key, signal.get()] as [
-							string,
-							T[Extract<keyof T, string>],
-						],
-				)
-				.sort(
-					compareFn
-						? (a, b) => compareFn(a[1], b[1])
-						: (a, b) => String(a[1]).localeCompare(String(b[1])),
-				)
-
-			// Create array of original keys in their new sorted order
-			const newOrder: string[] = entries.map(([key]) => String(key))
-			const newSignals = new Map<
-				string,
-				Signal<T[Extract<keyof T, string>] & {}>
-			>()
-
-			entries.forEach(([key], newIndex) => {
-				const oldKey = String(key)
-				const newKey = isArrayLike ? String(newIndex) : String(key)
-
-				const signal = signals.get(oldKey)
-				if (signal) newSignals.set(newKey, signal)
-			})
-
-			// Replace signals map
-			signals.clear()
-			newSignals.forEach((signal, key) => signals.set(key, signal))
-			notify(watchers)
-			emit(STORE_EVENT_SORT, newOrder)
+		length: {
+			get(): number {
+				subscribe(watchers)
+				return signals.size
+			},
 		},
-		addEventListener: eventTarget.addEventListener.bind(eventTarget),
-		removeEventListener: eventTarget.removeEventListener.bind(eventTarget),
-		dispatchEvent: eventTarget.dispatchEvent.bind(eventTarget),
-		size,
-	}
+	})
 
 	// Return proxy directly with integrated signal methods
-	return new Proxy({} as Store<T>, {
-		get(_target, prop) {
-			// Symbols
-			if (prop === Symbol.toStringTag) return TYPE_STORE
-			if (prop === Symbol.isConcatSpreadable) return isArrayLike
-			if (prop === Symbol.iterator)
-				return isArrayLike
-					? function* () {
-							const indexes = getSortedIndexes()
-							for (const index of indexes) {
-								const signal = signals.get(
-									String(index) as Extract<keyof T, string>,
-								)
-								if (signal) yield signal
-							}
-						}
-					: function* () {
-							for (const [key, signal] of signals)
-								yield [key, signal]
-						}
+	return new Proxy(store as Store<T>, {
+		get(target, prop) {
+			if (prop in target) return Reflect.get(target, prop)
 			if (isSymbol(prop)) return undefined
-
-			// Methods and Properties
-			if (prop in s) return s[prop]
-			if (prop === 'length' && isArrayLike) {
-				subscribe(watchers)
-				return size.get()
-			}
-
-			// Signals
-			return signals.get(prop as Extract<keyof T, string>)
+			return signals.get(prop)
 		},
-		has(_target, prop) {
-			const stringProp = String(prop)
-			return (
-				(stringProp &&
-					signals.has(stringProp as Extract<keyof T, string>)) ||
-				Object.keys(s).includes(stringProp) ||
-				prop === Symbol.toStringTag ||
-				prop === Symbol.iterator ||
-				prop === Symbol.isConcatSpreadable ||
-				(prop === 'length' && isArrayLike)
-			)
+		has(target, prop) {
+			if (prop in target) return true
+			return signals.has(String(prop))
 		},
-		ownKeys() {
-			return isArrayLike
-				? getSortedIndexes()
-						.map(key => String(key))
-						.concat(['length'])
-				: Array.from(signals.keys()).map(key => String(key))
+		ownKeys(target) {
+			const staticKeys = Reflect.ownKeys(target)
+			const signalKeys = isArrayLike
+				? getSortedIndexes().map(key => String(key))
+				: Array.from(signals.keys())
+			return [...new Set([...signalKeys, ...staticKeys])]
 		},
-		getOwnPropertyDescriptor(_target, prop) {
-			const nonEnumerable = <T>(value: T) => ({
-				enumerable: false,
-				configurable: true,
-				writable: false,
-				value,
-			})
-
-			if (prop === 'length' && isArrayLike)
-				return {
-					enumerable: true,
-					configurable: true,
-					writable: false,
-					value: size.get(),
-				}
-			if (prop === Symbol.isConcatSpreadable)
-				return nonEnumerable(isArrayLike)
-			if (prop === Symbol.toStringTag) return nonEnumerable(TYPE_STORE)
-			if (isSymbol(prop)) return undefined
-
-			if (Object.keys(s).includes(prop)) return nonEnumerable(s[prop])
+		getOwnPropertyDescriptor(target, prop) {
+			if (prop in target)
+				return Reflect.getOwnPropertyDescriptor(target, prop)
 
-			const signal = signals.get(prop as Extract<keyof T, string>)
+			const signal = signals.get(String(prop))
 			return signal
 				? {
 						enumerable: true,
@@ -528,20 +465,10 @@ const store = <T extends UnknownRecord | UnknownArray>(
  * @param {unknown} value - value to check
  * @returns {boolean} - true if the value is a Store instance, false otherwise
  */
-const isStore = <T extends UnknownRecordOrArray>(
+const isStore = <T extends UnknownRecord | UnknownArray>(
 	value: unknown,
 ): value is Store<T> => isObjectOfType(value, TYPE_STORE)
 
 /* === Exports === */
 
-export {
-	TYPE_STORE,
-	isStore,
-	store,
-	type Store,
-	type StoreAddEvent,
-	type StoreChangeEvent,
-	type StoreRemoveEvent,
-	type StoreSortEvent,
-	type StoreEventMap,
-}
+export { TYPE_STORE, isStore, createStore, type Store, type StoreChanges }