@zeix/cause-effect 0.17.3 → 0.18.1

package/archive/collection.ts

@@ -1,253 +0,0 @@
-import type { UnknownArray } from '../src/diff'
-import { match } from '../src/match'
-import { resolve } from '../src/resolve'
-import type { Signal } from '../src/signal'
-import {
-	createWatcher,
-	notifyWatchers,
-	subscribeActiveWatcher,
-	UNSET,
-	type Watcher,
-} from '../src/system'
-import { isAsyncFunction, isObjectOfType, isSymbol } from '../src/util'
-import { type Computed, createComputed } from './computed'
-import type { List } from './list'
-
-/* === Types === */
-
-type CollectionKeySignal<T extends {}> = T extends UnknownArray
-	? Collection<T>
-	: Computed<T>
-
-type CollectionCallback<T extends {} & { then?: undefined }, O extends {}> =
-	| ((originValue: O, abort: AbortSignal) => Promise<T>)
-	| ((originValue: O) => T)
-
-type Collection<T extends {}> = {
-	readonly [Symbol.toStringTag]: typeof TYPE_COLLECTION
-	readonly [Symbol.isConcatSpreadable]: boolean
-	[Symbol.iterator](): IterableIterator<CollectionKeySignal<T>>
-	readonly [n: number]: CollectionKeySignal<T>
-	readonly length: number
-
-	byKey(key: string): CollectionKeySignal<T> | undefined
-	get(): T[]
-	keyAt(index: number): string | undefined
-	indexOfKey(key: string): number
-	sort(compareFn?: (a: T, b: T) => number): void
-}
-
-/* === Constants === */
-
-const TYPE_COLLECTION = 'Collection' as const
-
-/* === Exported Functions === */
-
-/**
- * Collections - Read-Only Derived Array-Like Stores
- *
- * Collections are the read-only, derived counterpart to array-like Stores.
- * They provide reactive, memoized, and lazily-evaluated array transformations
- * while maintaining the familiar array-like store interface.
- *
- * @since 0.16.2
- * @param {List<O> | Collection<O>} origin - Origin of collection to derive values from
- * @param {ComputedCallback<ArrayItem<T>>} callback - Callback function to transform array items
- * @returns {Collection<T>} - New collection with reactive properties that preserves the original type T
- */
-const createCollection = <T extends {}, O extends {}>(
-	origin: List<O> | Collection<O>,
-	callback: CollectionCallback<T, O>,
-): Collection<T> => {
-	const watchers = new Set<Watcher>()
-	const signals = new Map<string, Signal<T>>()
-	const signalWatchers = new Map<string, Watcher>()
-
-	let order: string[] = []
-
-	// Add nested signal and effect
-	const addProperty = (key: string): boolean => {
-		const computedCallback = isAsyncFunction(callback)
-			? async (_: T, abort: AbortSignal) => {
-					const originSignal = origin.byKey(key)
-					if (!originSignal) return UNSET
-
-					let result = UNSET
-					match(resolve({ originSignal }), {
-						ok: async ({ originSignal: originValue }) => {
-							result = await callback(originValue, abort)
-						},
-						err: (errors: readonly Error[]) => {
-							console.log(errors)
-						},
-					})
-					return result
-				}
-			: () => {
-					const originSignal = origin.byKey(key)
-					if (!originSignal) return UNSET
-
-					let result = UNSET
-					match(resolve({ originSignal }), {
-						ok: ({ originSignal: originValue }) => {
-							result = (callback as (originValue: O) => T)(
-								originValue as unknown as O,
-							)
-						},
-						err: (errors: readonly Error[]) => {
-							console.log(errors)
-						},
-					})
-					return result
-				}
-
-		const signal = createComputed(computedCallback)
-
-		// Set internal states
-		signals.set(key, signal)
-		if (!order.includes(key)) order.push(key)
-		const watcher = createWatcher(
-			() => {
-				signal.get() // Subscribe to the signal
-			},
-			() => {},
-		)
-		watcher()
-		signalWatchers.set(key, watcher)
-		return true
-	}
-
-	// Initialize properties
-	for (let i = 0; i < origin.length; i++) {
-		const key = origin.keyAt(i)
-		if (!key) continue
-		addProperty(key)
-	}
-
-	// Get signal by key or index
-	const getSignal = (prop: string): Signal<T> | undefined => {
-		let key = prop
-		const index = Number(prop)
-		if (Number.isInteger(index) && index >= 0) key = order[index] ?? prop
-		return signals.get(key)
-	}
-
-	// Get current array
-	const current = (): T =>
-		order
-			.map(key => signals.get(key)?.get())
-			.filter(v => v !== UNSET) as unknown as T
-
-	// Methods and Properties
-	const collection: Record<PropertyKey, unknown> = {}
-	Object.defineProperties(collection, {
-		[Symbol.toStringTag]: {
-			value: TYPE_COLLECTION,
-		},
-		[Symbol.isConcatSpreadable]: {
-			value: true,
-		},
-		[Symbol.iterator]: {
-			value: function* () {
-				for (const key of order) {
-					const signal = signals.get(key)
-					if (signal) yield signal
-				}
-			},
-		},
-		byKey: {
-			value(key: string) {
-				return getSignal(key)
-			},
-		},
-		keyAt: {
-			value(index: number): string | undefined {
-				return order[index]
-			},
-		},
-		indexOfKey: {
-			value(key: string): number {
-				return order.indexOf(key)
-			},
-		},
-		get: {
-			value: (): T => {
-				subscribeActiveWatcher(watchers)
-				return current()
-			},
-		},
-		sort: {
-			value: (compareFn?: (a: T, b: T) => number): void => {
-				const entries = order
-					.map((key, index) => {
-						const signal = signals.get(key)
-						return [
-							index,
-							key,
-							signal ? signal.get() : undefined,
-						] as [number, string, T]
-					})
-					.sort(
-						compareFn
-							? (a, b) => compareFn(a[2], b[2])
-							: (a, b) =>
-									String(a[2]).localeCompare(String(b[2])),
-					)
-
-				// Set new order
-				order = entries.map(([_, key]) => key)
-
-				notifyWatchers(watchers)
-			},
-		},
-		length: {
-			get(): number {
-				subscribeActiveWatcher(watchers)
-				return signals.size
-			},
-		},
-	})
-
-	// Return proxy directly with integrated signal methods
-	return new Proxy(collection as Collection<T>, {
-		get(target, prop) {
-			if (prop in target) return Reflect.get(target, prop)
-			if (!isSymbol(prop)) return getSignal(prop)
-		},
-		has(target, prop) {
-			if (prop in target) return true
-			return signals.has(String(prop))
-		},
-		ownKeys(target) {
-			const staticKeys = Reflect.ownKeys(target)
-			return [...new Set([...order, ...staticKeys])]
-		},
-		getOwnPropertyDescriptor(target, prop) {
-			if (prop in target)
-				return Reflect.getOwnPropertyDescriptor(target, prop)
-			if (isSymbol(prop)) return undefined
-
-			const signal = getSignal(prop)
-			return signal
-				? {
-						enumerable: true,
-						configurable: true,
-						writable: true,
-						value: signal,
-					}
-				: undefined
-		},
-	})
-}
-
-const isCollection = /*#__PURE__*/ <T extends UnknownArray>(
-	value: unknown,
-): value is Collection<T> => isObjectOfType(value, TYPE_COLLECTION)
-
-export {
-	type Collection,
-	type CollectionCallback,
-	createCollection,
-	isCollection,
-	TYPE_COLLECTION,
-}

package/archive/composite.ts

@@ -1,85 +0,0 @@
-import type { DiffResult, UnknownRecord } from '../src/diff'
-import { guardMutableSignal } from '../src/errors'
-import type { Signal } from '../src/signal'
-import { batch } from '../src/system'
-
-/* === 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
-
-	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,
-		})
-	}
-
-	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))
-		return true
-	}
-
-	remove<K extends keyof T & string>(key: K): boolean {
-		return this.signals.delete(key)
-	}
-
-	change(changes: DiffResult): boolean {
-		// 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>] & {},
-				)
-		}
-
-		// Changes
-		if (Object.keys(changes.change).length) {
-			batch(() => {
-				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)
-				}
-			})
-		}
-
-		// Removals
-		if (Object.keys(changes.remove).length) {
-			for (const key in changes.remove)
-				this.remove(key as keyof T & string)
-		}
-
-		return changes.changed
-	}
-
-	clear(): boolean {
-		this.signals.clear()
-		return true
-	}
-}
-
-export { Composite }

package/archive/computed.ts

@@ -1,195 +0,0 @@
-import { isEqual } from '../src/diff'
-import {
-	CircularDependencyError,
-	createError,
-	InvalidCallbackError,
-	NullishSignalValueError,
-} from '../src/errors'
-import {
-	createWatcher,
-	flush,
-	notifyWatchers,
-	subscribeActiveWatcher,
-	UNSET,
-	type Watcher,
-} from '../src/system'
-import {
-	isAbortError,
-	isAsyncFunction,
-	isFunction,
-	isObjectOfType,
-} from '../src/util'
-
-/* === Types === */
-
-type Computed<T extends {}> = {
-	readonly [Symbol.toStringTag]: 'Computed'
-	get(): T
-}
-
-type ComputedCallback<T extends {} & { then?: undefined }> =
-	| ((oldValue: T, abort: AbortSignal) => Promise<T>)
-	| ((oldValue: T) => T)
-
-/* === Constants === */
-
-const TYPE_COMPUTED = 'Computed' as const
-
-/* === Functions === */
-
-/**
- * Create a derived signal from existing signals
- *
- * @since 0.9.0
- * @param {ComputedCallback<T>} callback - Computation callback function
- * @returns {Computed<T>} - Computed signal
- */
-const createComputed = <T extends {}>(
-	callback: ComputedCallback<T>,
-	initialValue: T = UNSET,
-): Computed<T> => {
-	if (!isComputedCallback(callback))
-		throw new InvalidCallbackError('computed', callback)
-	if (initialValue == null) throw new NullishSignalValueError('computed')
-
-	const watchers: Set<Watcher> = new Set()
-
-	// Internal state
-	let value: T = initialValue
-	let error: Error | undefined
-	let controller: AbortController | undefined
-	let dirty = true
-	let changed = false
-	let computing = false
-
-	// Functions to update internal state
-	const ok = (v: T): undefined => {
-		if (!isEqual(v, value)) {
-			value = v
-			changed = true
-		}
-		error = undefined
-		dirty = false
-	}
-	const nil = (): undefined => {
-		changed = UNSET !== value
-		value = UNSET
-		error = undefined
-	}
-	const err = (e: unknown): undefined => {
-		const newError = createError(e)
-		changed =
-			!error ||
-			newError.name !== error.name ||
-			newError.message !== error.message
-		value = UNSET
-		error = newError
-	}
-	const settle =
-		<T>(fn: (arg: T) => void) =>
-		(arg: T) => {
-			computing = false
-			controller = undefined
-			fn(arg)
-			if (changed) notifyWatchers(watchers)
-		}
-
-	// Own watcher: called when notified from sources (push)
-	const watcher = createWatcher(
-		() => {
-			dirty = true
-			controller?.abort()
-			if (watchers.size) notifyWatchers(watchers)
-			else watcher.stop()
-		},
-		() => {
-			if (computing) throw new CircularDependencyError('computed')
-			changed = false
-			if (isAsyncFunction(callback)) {
-				// Return current value until promise resolves
-				if (controller) return value
-				controller = new AbortController()
-				controller.signal.addEventListener(
-					'abort',
-					() => {
-						computing = false
-						controller = undefined
-						watcher.run() // Retry computation with updated state
-					},
-					{
-						once: true,
-					},
-				)
-			}
-			let result: T | Promise<T>
-			computing = true
-			try {
-				result = controller
-					? callback(value, controller.signal)
-					: (callback as (oldValue: T) => T)(value)
-			} catch (e) {
-				if (isAbortError(e)) nil()
-				else err(e)
-				computing = false
-				return
-			}
-			if (result instanceof Promise) result.then(settle(ok), settle(err))
-			else if (null == result || UNSET === result) nil()
-			else ok(result)
-			computing = false
-		},
-	)
-	watcher.onCleanup(() => {
-		controller?.abort()
-	})
-
-	const computed: Record<PropertyKey, unknown> = {}
-	Object.defineProperties(computed, {
-		[Symbol.toStringTag]: {
-			value: TYPE_COMPUTED,
-		},
-		get: {
-			value: (): T => {
-				subscribeActiveWatcher(watchers)
-				flush()
-				if (dirty) watcher.run()
-				if (error) throw error
-				return value
-			},
-		},
-	})
-	return computed as Computed<T>
-}
-
-/**
- * Check if a value is a computed signal
- *
- * @since 0.9.0
- * @param {unknown} value - Value to check
- * @returns {boolean} - true if value is a computed signal, false otherwise
- */
-const isComputed = /*#__PURE__*/ <T extends {}>(
-	value: unknown,
-): value is Computed<T> => isObjectOfType(value, TYPE_COMPUTED)
-
-/**
- * Check if the provided value is a callback that may be used as input for toSignal() to derive a computed state
- *
- * @since 0.12.0
- * @param {unknown} value - Value to check
- * @returns {boolean} - true if value is a callback or callbacks object, false otherwise
- */
-const isComputedCallback = /*#__PURE__*/ <T extends {}>(
-	value: unknown,
-): value is ComputedCallback<T> => isFunction(value) && value.length < 3
-
-/* === Exports === */
-
-export {
-	TYPE_COMPUTED,
-	createComputed,
-	isComputed,
-	isComputedCallback,
-	type Computed,
-	type ComputedCallback,
-}