@zeix/cause-effect 0.14.2 → 0.15.0

package/src/store.ts

@@ -0,0 +1,325 @@
+import { diff, type UnknownRecord } from './diff'
+import { effect } from './effect'
+import {
+	batch,
+	type Cleanup,
+	notify,
+	subscribe,
+	type Watcher,
+} from './scheduler'
+import { type Signal, toMutableSignal, UNSET } from './signal'
+import { type State, state } from './state'
+import { hasMethod, isObjectOfType } from './util'
+
+/* === Constants === */
+
+const TYPE_STORE = 'Store'
+
+/* === Types === */
+
+interface StoreAddEvent<T extends UnknownRecord> extends CustomEvent {
+	type: 'store-add'
+	detail: Partial<T>
+}
+
+interface StoreChangeEvent<T extends UnknownRecord> extends CustomEvent {
+	type: 'store-change'
+	detail: Partial<T>
+}
+
+interface StoreRemoveEvent<T extends UnknownRecord> extends CustomEvent {
+	type: 'store-remove'
+	detail: Partial<T>
+}
+
+type StoreEventMap<T extends UnknownRecord> = {
+	'store-add': StoreAddEvent<T>
+	'store-change': StoreChangeEvent<T>
+	'store-remove': StoreRemoveEvent<T>
+}
+
+interface StoreEventTarget<T extends UnknownRecord> extends EventTarget {
+	addEventListener<K extends keyof StoreEventMap<T>>(
+		type: K,
+		listener: (event: StoreEventMap<T>[K]) => void,
+		options?: boolean | AddEventListenerOptions,
+	): void
+	addEventListener(
+		type: string,
+		listener: EventListenerOrEventListenerObject,
+		options?: boolean | AddEventListenerOptions,
+	): void
+
+	removeEventListener<K extends keyof StoreEventMap<T>>(
+		type: K,
+		listener: (event: StoreEventMap<T>[K]) => void,
+		options?: boolean | EventListenerOptions,
+	): void
+	removeEventListener(
+		type: string,
+		listener: EventListenerOrEventListenerObject,
+		options?: boolean | EventListenerOptions,
+	): void
+
+	dispatchEvent(event: Event): boolean
+}
+
+type Store<T extends UnknownRecord = UnknownRecord> = {
+	[K in keyof T & string]: T[K] extends UnknownRecord
+		? Store<T[K]>
+		: State<T[K]>
+} & StoreEventTarget<T> & {
+		[Symbol.toStringTag]: 'Store'
+		[Symbol.iterator](): IterableIterator<[string, Signal<T[keyof T]>]>
+
+		// Signal methods
+		add<K extends keyof T & string>(key: K, value: T[K]): void
+		get(): T
+		remove<K extends keyof T & string>(key: K): void
+		set(value: T): void
+		update(updater: (value: T) => T): void
+
+		// Interals signals
+		size: State<number>
+	}
+
+/* === Functions === */
+
+/**
+ * Create a new store with deeply nested reactive properties
+ *
+ * @since 0.15.0
+ * @param {T} initialValue - initial object value of the store
+ * @returns {Store<T>} - new store with reactive properties
+ */
+const store = <T extends UnknownRecord>(initialValue: T): Store<T> => {
+	const watchers: Set<Watcher> = new Set()
+	const eventTarget = new EventTarget()
+	const signals: Map<
+		keyof T & string,
+		Store<T[keyof T & string]> | State<T[keyof T & string]>
+	> = new Map()
+	const cleanups = new Map<keyof T & string, Cleanup>()
+
+	// Internal state
+	const size = state(0)
+
+	// Get current record
+	const current = () => {
+		const record: Partial<T> = {}
+		for (const [key, value] of signals) {
+			record[key] = value.get()
+		}
+		return record as T
+	}
+
+	// Emit event
+	const emit = (type: keyof StoreEventMap<T>, detail: Partial<T>) =>
+		eventTarget.dispatchEvent(new CustomEvent(type, { detail }))
+
+	// Add nested signal and effect
+	const addSignalAndEffect = <K extends keyof T & string>(
+		key: K,
+		value: T[K],
+	) => {
+		const signal = toMutableSignal<T[keyof T & string]>(value)
+		signals.set(key, signal)
+		const cleanup = effect(() => {
+			const value = signal.get()
+			if (value != null)
+				emit('store-change', { [key]: value } as unknown as Partial<T>)
+		})
+		cleanups.set(key, cleanup)
+	}
+
+	// Remove nested signal and effect
+	const removeSignalAndEffect = <K extends keyof T & string>(key: K) => {
+		signals.delete(key)
+		const cleanup = cleanups.get(key)
+		if (cleanup) cleanup()
+		cleanups.delete(key)
+	}
+
+	// Reconcile data and dispatch events
+	const reconcile = (oldValue: T, newValue: T): boolean => {
+		const changes = diff(oldValue, newValue)
+
+		batch(() => {
+			if (Object.keys(changes.add).length) {
+				for (const key in changes.add) {
+					const value = changes.add[key]
+					if (value != null) addSignalAndEffect(key, value)
+				}
+				emit('store-add', changes.add)
+			}
+			if (Object.keys(changes.change).length) {
+				for (const key in changes.change) {
+					const signal = signals.get(key as keyof T & string)
+					const value = changes.change[key]
+					if (
+						signal &&
+						value != null &&
+						hasMethod<Signal<T[keyof T & string]>>(signal, 'set')
+					)
+						signal.set(value)
+				}
+				emit('store-change', changes.change)
+			}
+			if (Object.keys(changes.remove).length) {
+				for (const key in changes.remove) {
+					removeSignalAndEffect(key)
+				}
+				emit('store-remove', changes.remove)
+			}
+
+			size.set(signals.size)
+		})
+
+		return changes.changed
+	}
+
+	// Initialize data
+	reconcile({} as T, initialValue)
+
+	// Queue initial additions event to allow listeners to be added first
+	setTimeout(() => {
+		const initialAdditionsEvent = new CustomEvent('store-add', {
+			detail: initialValue as Partial<T>,
+		}) as StoreAddEvent<T>
+		eventTarget.dispatchEvent(initialAdditionsEvent)
+	}, 0)
+
+	const storeProps = [
+		'add',
+		'get',
+		'remove',
+		'set',
+		'update',
+		'addEventListener',
+		'removeEventListener',
+		'dispatchEvent',
+		'size',
+	]
+
+	// Return proxy directly with integrated signal methods
+	return new Proxy({} as Store<T>, {
+		get(_target, prop) {
+			const key = String(prop)
+
+			// Handle signal methods and size property
+			switch (prop) {
+				case 'add':
+					return <K extends keyof T & string>(
+						k: K,
+						v: T[K],
+					): void => {
+						if (!signals.has(k)) {
+							addSignalAndEffect(k, v)
+							notify(watchers)
+							emit('store-add', {
+								[k]: v,
+							} as unknown as Partial<T>)
+							size.set(signals.size)
+						}
+					}
+				case 'get':
+					return (): T => {
+						subscribe(watchers)
+						return current()
+					}
+				case 'remove':
+					return <K extends keyof T & string>(k: K): void => {
+						if (signals.has(k)) {
+							removeSignalAndEffect(k)
+							notify(watchers)
+							emit('store-remove', { [k]: UNSET } as Partial<T>)
+							size.set(signals.size)
+						}
+					}
+				case 'set':
+					return (v: T): void => {
+						if (reconcile(current(), v)) {
+							notify(watchers)
+							if (UNSET === v) watchers.clear()
+						}
+					}
+				case 'update':
+					return (fn: (v: T) => T): void => {
+						const oldValue = current()
+						const newValue = fn(oldValue)
+						if (reconcile(oldValue, newValue)) {
+							notify(watchers)
+							if (UNSET === newValue) watchers.clear()
+						}
+					}
+				case 'addEventListener':
+					return eventTarget.addEventListener.bind(eventTarget)
+				case 'removeEventListener':
+					return eventTarget.removeEventListener.bind(eventTarget)
+				case 'dispatchEvent':
+					return eventTarget.dispatchEvent.bind(eventTarget)
+				case 'size':
+					return size
+			}
+
+			// Handle symbol properties
+			if (prop === Symbol.toStringTag) return TYPE_STORE
+			if (prop === Symbol.iterator) {
+				return function* () {
+					for (const [key, signal] of signals) {
+						yield [key, signal as Signal<T[keyof T]>]
+					}
+				}
+			}
+
+			// Handle data properties - return signals
+			return signals.get(key)
+		},
+		has(_target, prop) {
+			const key = String(prop)
+			return (
+				signals.has(key) ||
+				storeProps.includes(key) ||
+				prop === Symbol.toStringTag ||
+				prop === Symbol.iterator
+			)
+		},
+		ownKeys() {
+			return Array.from(signals.keys())
+		},
+		getOwnPropertyDescriptor(_target, prop) {
+			const signal = signals.get(String(prop))
+			return signal
+				? {
+						enumerable: true,
+						configurable: true,
+						writable: true,
+						value: signal,
+					}
+				: undefined
+		},
+	})
+}
+
+/**
+ * Check if the provided value is a Store instance
+ *
+ * @since 0.15.0
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if the value is a Store instance, false otherwise
+ */
+const isStore = <T extends UnknownRecord>(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 StoreEventMap,
+}

package/src/util.ts

@@ -1,15 +1,54 @@
 /* === Utility Functions === */
 
+const isNumber = /*#__PURE__*/ (value: unknown): value is number =>
+	typeof value === 'number'
+
+const isString = /*#__PURE__*/ (value: unknown): value is string =>
+	typeof value === 'string'
+
 const isFunction = /*#__PURE__*/ <T>(
-	value: unknown,
-): value is (...args: unknown[]) => T => typeof value === 'function'
+	fn: unknown,
+): fn is (...args: unknown[]) => T => typeof fn === 'function'
+
+const isAsyncFunction = /*#__PURE__*/ <T>(
+	fn: unknown,
+): fn is (...args: unknown[]) => Promise<T> =>
+	isFunction(fn) && fn.constructor.name === 'AsyncFunction'
 
 const isObjectOfType = /*#__PURE__*/ <T>(
 	value: unknown,
 	type: string,
 ): value is T => Object.prototype.toString.call(value) === `[object ${type}]`
 
-const toError = (reason: unknown): Error =>
+const isRecord = /*#__PURE__*/ <T extends Record<string, unknown>>(
+	value: unknown,
+): value is T => isObjectOfType(value, 'Object')
+
+const isPrimitive = /*#__PURE__*/ (value: unknown): boolean =>
+	typeof value !== 'object' && !isFunction(value)
+
+const arrayToRecord = /*#__PURE__*/ <T extends unknown & {}>(
+	array: T[],
+): Record<string, T> => {
+	const record: Record<string, T> = {}
+	for (let i = 0; i < array.length; i++) {
+		if (i in array) record[String(i)] = array[i]
+	}
+	return record
+}
+
+const hasMethod = /*#__PURE__*/ <
+	T extends object & Record<string, (...args: unknown[]) => unknown>,
+>(
+	obj: T,
+	methodName: string,
+): obj is T & Record<string, (...args: unknown[]) => unknown> =>
+	methodName in obj && isFunction(obj[methodName])
+
+const isAbortError = /*#__PURE__*/ (error: unknown): boolean =>
+	error instanceof DOMException && error.name === 'AbortError'
+
+const toError = /*#__PURE__*/ (reason: unknown): Error =>
 	reason instanceof Error ? reason : Error(String(reason))
 
 class CircularDependencyError extends Error {
@@ -21,4 +60,17 @@ class CircularDependencyError extends Error {
 
 /* === Exports === */
 
-export { isFunction, isObjectOfType, toError, CircularDependencyError }
+export {
+	isNumber,
+	isString,
+	isFunction,
+	isAsyncFunction,
+	isObjectOfType,
+	isRecord,
+	isPrimitive,
+	arrayToRecord,
+	hasMethod,
+	isAbortError,
+	toError,
+	CircularDependencyError,
+}

package/test/batch.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { batch, computed, effect, state } from '../'
+import { batch, computed, effect, match, resolve, state } from '../'
 
 /* === Tests === */
 
@@ -28,13 +28,15 @@ describe('Batch', () => {
 		const sum = computed(() => a.get() + b.get() + c.get())
 		let result = 0
 		let count = 0
-		effect({
-			signals: [sum],
-			ok: (res): undefined => {
-				result = res
-				count++
-			},
-			err: (): undefined => {},
+		effect(() => {
+			const resolved = resolve({ sum })
+			match(resolved, {
+				ok: ({ sum: res }) => {
+					result = res
+					count++
+				},
+				err: () => {},
+			})
 		})
 		batch(() => {
 			a.set(6)
@@ -61,17 +63,19 @@ describe('Batch', () => {
 		let errCount = 0
 
 		// Effect: switch cases for the result
-		effect({
-			signals: [sum],
-			ok: (v): undefined => {
-				result = v
-				okCount++
-				// console.log('Sum:', v)
-			},
-			err: (_error): undefined => {
-				errCount++
-				// console.error('Error:', error)
-			},
+		effect(() => {
+			const resolved = resolve({ sum })
+			match(resolved, {
+				ok: ({ sum: v }) => {
+					result = v
+					okCount++
+					// console.log('Sum:', v)
+				},
+				err: () => {
+					errCount++
+					// console.error('Error:', error)
+				},
+			})
 		})
 
 		expect(okCount).toBe(1)

package/test/benchmark.test.ts

@@ -169,7 +169,7 @@ describe('Basic test', () => {
 describe('Kairo tests', () => {
 	const name = framework.name
 
-	test(`${name} | avoidable propagation`, () => {
+	test(`${name} | avoidable propagation`, async () => {
 		const head = framework.signal(0)
 		const computed1 = framework.computed(() => head.read())
 		const computed2 = framework.computed(() => {
@@ -201,7 +201,7 @@ describe('Kairo tests', () => {
 		}
 	})
 
-	test(`${name} | broad propagation`, () => {
+	test(`${name} | broad propagation`, async () => {
 		const head = framework.signal(0)
 		let last = head as { read: () => number }
 		const callCounter = new Counter()
@@ -235,7 +235,7 @@ describe('Kairo tests', () => {
 		}
 	})
 
-	test(`${name} | deep propagation`, () => {
+	test(`${name} | deep propagation`, async () => {
 		const len = 50
 		const head = framework.signal(0)
 		let current = head as { read: () => number }
@@ -268,7 +268,7 @@ describe('Kairo tests', () => {
 		}
 	})
 
-	test(`${name} | diamond`, () => {
+	test(`${name} | diamond`, async () => {
 		const width = 5
 		const head = framework.signal(0)
 		const current: { read(): number }[] = []
@@ -301,7 +301,7 @@ describe('Kairo tests', () => {
 		}
 	})
 
-	test(`${name} | mux`, () => {
+	test(`${name} | mux`, async () => {
 		const heads = new Array(100).fill(null).map(_ => framework.signal(0))
 		const mux = framework.computed(() => {
 			return Object.fromEntries(heads.map(h => h.read()).entries())
@@ -332,7 +332,7 @@ describe('Kairo tests', () => {
 		}
 	})
 
-	test(`${name} | repeated observers`, () => {
+	test(`${name} | repeated observers`, async () => {
 		const size = 30
 		const head = framework.signal(0)
 		const current = framework.computed(() => {
@@ -365,7 +365,7 @@ describe('Kairo tests', () => {
 		}
 	})
 
-	test(`${name} | triangle`, () => {
+	test(`${name} | triangle`, async () => {
 		const width = 10
 		const head = framework.signal(0)
 		let current = head as { read: () => number }
@@ -410,7 +410,7 @@ describe('Kairo tests', () => {
 		}
 	})
 
-	test(`${name} | unstable`, () => {
+	test(`${name} | unstable`, async () => {
 		const head = framework.signal(0)
 		const double = framework.computed(() => head.read() * 2)
 		const inverse = framework.computed(() => -head.read())

package/test/computed.test.ts

@@ -4,9 +4,11 @@ import {
 	effect,
 	isComputed,
 	isState,
+	match,
+	resolve,
 	state,
 	UNSET,
-} from '../index.ts'
+} from '../'
 
 /* === Utility Functions === */
 
@@ -134,7 +136,7 @@ describe('Computed', () => {
 		const b = computed(() => x.get())
 		const c = computed(() => {
 			count++
-			return a.get() + ' ' + b.get()
+			return `${a.get()} ${b.get()}`
 		})
 		expect(c.get()).toBe('a a')
 		expect(count).toBe(1)
@@ -282,15 +284,17 @@ describe('Computed', () => {
 		let okCount = 0
 		let nilCount = 0
 		let result: number = 0
-		effect({
-			signals: [derived],
-			ok: (v): undefined => {
-				result = v
-				okCount++
-			},
-			nil: (): undefined => {
-				nilCount++
-			},
+		effect(() => {
+			const resolved = resolve({ derived })
+			match(resolved, {
+				ok: ({ derived: v }) => {
+					result = v
+					okCount++
+				},
+				nil: () => {
+					nilCount++
+				},
+			})
 		})
 		cause.set(43)
 		expect(okCount).toBe(0)