@zeix/cause-effect 0.17.2 → 0.18.0

package/src/classes/collection.ts

@@ -1,298 +0,0 @@
-import {
-	InvalidCollectionSourceError,
-	InvalidHookError,
-	validateCallback,
-} from '../errors'
-import type { Signal } from '../signal'
-import {
-	type Cleanup,
-	createWatcher,
-	HOOK_ADD,
-	HOOK_CHANGE,
-	HOOK_REMOVE,
-	HOOK_SORT,
-	HOOK_WATCH,
-	type Hook,
-	type HookCallback,
-	type HookCallbacks,
-	isHandledHook,
-	notifyWatchers,
-	subscribeActiveWatcher,
-	trackSignalReads,
-	triggerHook,
-	UNSET,
-	type Watcher,
-} from '../system'
-import { isAsyncFunction, isFunction, isObjectOfType } from '../util'
-import { type Computed, createComputed } from './computed'
-import { isList, type List } from './list'
-
-/* === Types === */
-
-type CollectionSource<T extends {}> = List<T> | Collection<T>
-
-type CollectionCallback<T extends {}, U extends {}> =
-	| ((sourceValue: U) => T)
-	| ((sourceValue: U, abort: AbortSignal) => Promise<T>)
-
-type Collection<T extends {}> = {
-	readonly [Symbol.toStringTag]: 'Collection'
-	readonly [Symbol.isConcatSpreadable]: true
-	[Symbol.iterator](): IterableIterator<Signal<T>>
-	keys(): IterableIterator<string>
-	get: () => T[]
-	at: (index: number) => Signal<T> | undefined
-	byKey: (key: string) => Signal<T> | undefined
-	keyAt: (index: number) => string | undefined
-	indexOfKey: (key: string) => number | undefined
-	on: <K extends Hook>(type: K, callback: HookCallback) => Cleanup
-	deriveCollection: <R extends {}>(
-		callback: CollectionCallback<R, T>,
-	) => DerivedCollection<R, T>
-	readonly length: number
-}
-
-/* === Constants === */
-
-const TYPE_COLLECTION = 'Collection' as const
-
-/* === Class === */
-
-class DerivedCollection<T extends {}, U extends {}> implements Collection<T> {
-	#watchers = new Set<Watcher>()
-	#source: CollectionSource<U>
-	#callback: CollectionCallback<T, U>
-	#signals = new Map<string, Computed<T>>()
-	#ownWatchers = new Map<string, Watcher>()
-	#hookCallbacks: HookCallbacks = {}
-	#order: string[] = []
-
-	constructor(
-		source: CollectionSource<U> | (() => CollectionSource<U>),
-		callback: CollectionCallback<T, U>,
-	) {
-		validateCallback(TYPE_COLLECTION, callback)
-
-		if (isFunction(source)) source = source()
-		if (!isCollectionSource(source))
-			throw new InvalidCollectionSourceError(TYPE_COLLECTION, source)
-		this.#source = source
-
-		this.#callback = callback
-
-		for (let i = 0; i < this.#source.length; i++) {
-			const key = this.#source.keyAt(i)
-			if (!key) continue
-
-			this.#add(key)
-		}
-
-		this.#source.on(HOOK_ADD, additions => {
-			if (!additions) return
-			for (const key of additions) {
-				if (!this.#signals.has(key)) {
-					this.#add(key)
-					// For async computations, trigger initial computation
-					const signal = this.#signals.get(key)
-					if (signal && isAsyncCollectionCallback(this.#callback))
-						signal.get()
-				}
-			}
-			notifyWatchers(this.#watchers)
-			triggerHook(this.#hookCallbacks.add, additions)
-		})
-
-		this.#source.on(HOOK_REMOVE, removals => {
-			if (!removals) return
-			for (const key of removals) {
-				if (!this.#signals.has(key)) continue
-
-				this.#signals.delete(key)
-				const index = this.#order.indexOf(key)
-				if (index >= 0) this.#order.splice(index, 1)
-
-				const watcher = this.#ownWatchers.get(key)
-				if (watcher) {
-					watcher.stop()
-					this.#ownWatchers.delete(key)
-				}
-			}
-			this.#order = this.#order.filter(() => true) // Compact array
-			notifyWatchers(this.#watchers)
-			triggerHook(this.#hookCallbacks.remove, removals)
-		})
-
-		this.#source.on(HOOK_SORT, newOrder => {
-			if (newOrder) this.#order = [...newOrder]
-			notifyWatchers(this.#watchers)
-			triggerHook(this.#hookCallbacks.sort, newOrder)
-		})
-	}
-
-	#add(key: string): boolean {
-		const computedCallback = isAsyncCollectionCallback<T>(this.#callback)
-			? async (_: T, abort: AbortSignal) => {
-					const sourceValue = this.#source.byKey(key)?.get() as U
-					if (sourceValue === UNSET) return UNSET
-					return this.#callback(sourceValue, abort)
-				}
-			: () => {
-					const sourceValue = this.#source.byKey(key)?.get() as U
-					if (sourceValue === UNSET) return UNSET
-					return (this.#callback as (sourceValue: U) => T)(
-						sourceValue,
-					)
-				}
-
-		const signal = createComputed(computedCallback)
-
-		this.#signals.set(key, signal)
-		if (!this.#order.includes(key)) this.#order.push(key)
-		if (this.#hookCallbacks.change?.size) this.#addWatcher(key)
-		return true
-	}
-
-	#addWatcher(key: string): void {
-		const watcher = createWatcher(() => {
-			trackSignalReads(watcher, () => {
-				this.#signals.get(key)?.get() // Subscribe to the signal
-			})
-		})
-		this.#ownWatchers.set(key, watcher)
-		watcher()
-	}
-
-	get [Symbol.toStringTag](): 'Collection' {
-		return TYPE_COLLECTION
-	}
-
-	get [Symbol.isConcatSpreadable](): true {
-		return true
-	}
-
-	*[Symbol.iterator](): IterableIterator<Computed<T>> {
-		for (const key of this.#order) {
-			const signal = this.#signals.get(key)
-			if (signal) yield signal as Computed<T>
-		}
-	}
-
-	keys(): IterableIterator<string> {
-		return this.#order.values()
-	}
-
-	get(): T[] {
-		subscribeActiveWatcher(this.#watchers, this.#hookCallbacks[HOOK_WATCH])
-		return this.#order
-			.map(key => this.#signals.get(key)?.get())
-			.filter(v => v != null && v !== UNSET) as T[]
-	}
-
-	at(index: number): Computed<T> | undefined {
-		return this.#signals.get(this.#order[index])
-	}
-
-	byKey(key: string): Computed<T> | undefined {
-		return this.#signals.get(key)
-	}
-
-	keyAt(index: number): string | undefined {
-		return this.#order[index]
-	}
-
-	indexOfKey(key: string): number {
-		return this.#order.indexOf(key)
-	}
-
-	on(type: Hook, callback: HookCallback): Cleanup {
-		if (
-			isHandledHook(type, [
-				HOOK_ADD,
-				HOOK_CHANGE,
-				HOOK_REMOVE,
-				HOOK_SORT,
-				HOOK_WATCH,
-			])
-		) {
-			this.#hookCallbacks[type] ||= new Set()
-			this.#hookCallbacks[type].add(callback)
-			if (type === HOOK_CHANGE && !this.#ownWatchers.size) {
-				for (const key of this.#signals.keys()) this.#addWatcher(key)
-			}
-
-			return () => {
-				this.#hookCallbacks[type]?.delete(callback)
-				if (type === HOOK_CHANGE && !this.#hookCallbacks.change?.size) {
-					if (this.#ownWatchers.size) {
-						for (const watcher of this.#ownWatchers.values())
-							watcher.stop()
-						this.#ownWatchers.clear()
-					}
-				}
-			}
-		}
-		throw new InvalidHookError(TYPE_COLLECTION, type)
-	}
-
-	deriveCollection<R extends {}>(
-		callback: (sourceValue: T) => R,
-	): DerivedCollection<R, T>
-	deriveCollection<R extends {}>(
-		callback: (sourceValue: T, abort: AbortSignal) => Promise<R>,
-	): DerivedCollection<R, T>
-	deriveCollection<R extends {}>(
-		callback: CollectionCallback<R, T>,
-	): DerivedCollection<R, T> {
-		return new DerivedCollection(this, callback)
-	}
-
-	get length(): number {
-		subscribeActiveWatcher(this.#watchers, this.#hookCallbacks[HOOK_WATCH])
-		return this.#order.length
-	}
-}
-
-/* === Functions === */
-
-/**
- * Check if a value is a collection signal
- *
- * @since 0.17.2
- * @param {unknown} value - Value to check
- * @returns {boolean} - True if value is a collection signal, false otherwise
- */
-const isCollection = /*#__PURE__*/ <T extends {}>(
-	value: unknown,
-): value is Collection<T> => isObjectOfType(value, TYPE_COLLECTION)
-
-/**
- * Check if a value is a collection source
- *
- * @since 0.17.0
- * @param {unknown} value - Value to check
- * @returns {boolean} - True if value is a collection source, false otherwise
- */
-const isCollectionSource = /*#__PURE__*/ <T extends {}>(
-	value: unknown,
-): value is CollectionSource<T> => isList(value) || isCollection(value)
-
-/**
- * Check if the provided callback is an async function
- *
- * @since 0.17.0
- * @param {unknown} callback - Value to check
- * @returns {boolean} - True if value is an async collection callback, false otherwise
- */
-const isAsyncCollectionCallback = <T extends {}>(
-	callback: unknown,
-): callback is (sourceValue: unknown, abort: AbortSignal) => Promise<T> =>
-	isAsyncFunction(callback)
-
-export {
-	type Collection,
-	type CollectionSource,
-	type CollectionCallback,
-	DerivedCollection,
-	isCollection,
-	TYPE_COLLECTION,
-}

package/src/classes/composite.ts

@@ -1,171 +0,0 @@
-import type { DiffResult, UnknownRecord } from '../diff'
-import { guardMutableSignal, InvalidHookError } from '../errors'
-import type { Signal } from '../signal'
-import {
-	batchSignalWrites,
-	type Cleanup,
-	createWatcher,
-	HOOK_ADD,
-	HOOK_CHANGE,
-	HOOK_REMOVE,
-	type HookCallback,
-	type HookCallbacks,
-	isHandledHook,
-	trackSignalReads,
-	triggerHook,
-	type Watcher,
-} from '../system'
-
-/* === Types === */
-
-type CompositeHook = 'add' | 'change' | 'remove'
-
-/* === Class Definitions === */
-
-class Composite<T extends UnknownRecord, S extends Signal<T[keyof T] & {}>> {
-	signals = new Map<string, S>()
-	#validate: <K extends keyof T & string>(
-		key: K,
-		value: unknown,
-	) => value is T[K] & {}
-	#create: <V extends T[keyof T] & {}>(value: V) => S
-	#watchers = new Map<string, Watcher>()
-	#hookCallbacks: HookCallbacks = {}
-	#batching = false
-
-	constructor(
-		values: T,
-		validate: <K extends keyof T & string>(
-			key: K,
-			value: unknown,
-		) => value is T[K] & {},
-		create: <V extends T[keyof T] & {}>(value: V) => S,
-	) {
-		this.#validate = validate
-		this.#create = create
-		this.change(
-			{
-				add: values,
-				change: {},
-				remove: {},
-				changed: true,
-			},
-			true,
-		)
-	}
-
-	#addWatcher(key: string): void {
-		const watcher = createWatcher(() => {
-			trackSignalReads(watcher, () => {
-				this.signals.get(key)?.get() // Subscribe to the signal
-				if (!this.#batching)
-					triggerHook(this.#hookCallbacks.change, [key])
-			})
-		})
-		this.#watchers.set(key, watcher)
-		watcher()
-	}
-
-	add<K extends keyof T & string>(key: K, value: T[K]): boolean {
-		if (!this.#validate(key, value)) return false
-
-		this.signals.set(key, this.#create(value))
-		if (this.#hookCallbacks.change?.size) this.#addWatcher(key)
-
-		if (!this.#batching) triggerHook(this.#hookCallbacks.add, [key])
-		return true
-	}
-
-	remove<K extends keyof T & string>(key: K): boolean {
-		const ok = this.signals.delete(key)
-		if (!ok) return false
-
-		const watcher = this.#watchers.get(key)
-		if (watcher) {
-			watcher.stop()
-			this.#watchers.delete(key)
-		}
-
-		if (!this.#batching) triggerHook(this.#hookCallbacks.remove, [key])
-		return true
-	}
-
-	change(changes: DiffResult, initialRun?: boolean): boolean {
-		this.#batching = true
-
-		// Additions
-		if (Object.keys(changes.add).length) {
-			for (const key in changes.add)
-				this.add(
-					key as Extract<keyof T, string>,
-					changes.add[key] as T[Extract<keyof T, string>] & {},
-				)
-
-			// Queue initial additions event to allow listeners to be added first
-			const notify = () =>
-				triggerHook(this.#hookCallbacks.add, Object.keys(changes.add))
-			if (initialRun) setTimeout(notify, 0)
-			else notify()
-		}
-
-		// Changes
-		if (Object.keys(changes.change).length) {
-			batchSignalWrites(() => {
-				for (const key in changes.change) {
-					const value = changes.change[key]
-					if (!this.#validate(key as keyof T & string, value))
-						continue
-
-					const signal = this.signals.get(key)
-					if (guardMutableSignal(`list item "${key}"`, value, signal))
-						signal.set(value)
-				}
-			})
-			triggerHook(this.#hookCallbacks.change, Object.keys(changes.change))
-		}
-
-		// Removals
-		if (Object.keys(changes.remove).length) {
-			for (const key in changes.remove)
-				this.remove(key as keyof T & string)
-			triggerHook(this.#hookCallbacks.remove, Object.keys(changes.remove))
-		}
-
-		this.#batching = false
-		return changes.changed
-	}
-
-	clear(): boolean {
-		const keys = Array.from(this.signals.keys())
-		this.signals.clear()
-		this.#watchers.clear()
-		triggerHook(this.#hookCallbacks.remove, keys)
-		return true
-	}
-
-	on(type: CompositeHook, callback: HookCallback): Cleanup {
-		if (!isHandledHook(type, [HOOK_ADD, HOOK_CHANGE, HOOK_REMOVE]))
-			throw new InvalidHookError('Composite', type)
-
-		this.#hookCallbacks[type] ||= new Set()
-		this.#hookCallbacks[type].add(callback)
-		if (type === HOOK_CHANGE && !this.#watchers.size) {
-			this.#batching = true
-			for (const key of this.signals.keys()) this.#addWatcher(key)
-			this.#batching = false
-		}
-
-		return () => {
-			this.#hookCallbacks[type]?.delete(callback)
-			if (type === HOOK_CHANGE && !this.#hookCallbacks.change?.size) {
-				if (this.#watchers.size) {
-					for (const watcher of this.#watchers.values())
-						watcher.stop()
-					this.#watchers.clear()
-				}
-			}
-		}
-	}
-}
-
-export { Composite, type CompositeHook as CompositeListeners }