mutts 1.0.6 → 1.0.8

package/src/reactive/buffer.ts

@@ -0,0 +1,168 @@
+import { FoolProof } from '../utils'
+import { effect, untracked } from './effects'
+import { cleanedBy, cleanup } from './interface'
+import { memoize } from './memoize'
+import { reactive } from './proxy'
+import type { ScopedCallback } from './types'
+
+/**
+ * Result of a reactive scan, which is a reactive array of accumulated values
+ * with an attached cleanup function.
+ */
+export type ScanResult<Output> = readonly Output[] & { [cleanup]: ScopedCallback }
+
+/**
+ * Perform a reactive scan over an array of items.
+ *
+ * This implementation is highly optimized for performance and fine-grained reactivity:
+ * - **Incremental Updates**: Changes to an item only trigger re-computation from that 
+ *   point onwards in the result chain.
+ * - **Move Optimization**: If items are moved within the array, their accumulated 
+ *   values are reused as long as their predecessor remains the same.
+ * - **Duplicate Support**: Correctly handles multiple occurrences of the same object 
+ *   instance using an internal occurrence tracking mechanism.
+ * - **Memory Efficient**: Uses `WeakMap` for caching intermediates, which are 
+ *   automatically cleared when source items are garbage collected.
+ *
+ * @example
+ * ```typescript
+ * const source = reactive([{ val: 1 }, { val: 2 }, { val: 3 }])
+ * const sum = scan(source, (acc, item) => acc + item.val, 0)
+ * 
+ * expect([...sum]).toEqual([1, 3, 6])
+ * 
+ * // Modifying an item only re-computes subsequent sums
+ * source[1].val = 10
+ * expect([...sum]).toEqual([1, 11, 14])
+ * ```
+ *
+ * @param source The source array of objects (will be made reactive)
+ * @param callback The accumulator function called with (accumulator, currentItem)
+ * @param initialValue The starting value for the accumulation
+ * @returns A reactive array of accumulated values, with a [cleanup] property to stop the tracking
+ */
+export function scan<Input extends object, Output>(
+	source: readonly Input[],
+	callback: (acc: Output, val: Input) => Output,
+	initialValue: Output
+): ScanResult<Output> {
+	const observedSource = reactive(source)
+	const result = reactive([] as Output[])
+	
+	// Track effects for each index to dispose them when the array shrinks
+	const indexEffects = new Map<number, ScopedCallback>()
+	// Mapping from index to its current intermediate object
+	const indexToIntermediate = reactive([] as Intermediate[])
+	const intermediaries = new WeakMap<Input, Intermediate[]>()
+
+	class Intermediate {
+		public prev: Intermediate | undefined
+		constructor(public val: Input, prev: Intermediate | undefined) {
+			this.prev = prev
+		}
+
+		@memoize
+		get acc(): Output {
+			const prevAcc = this.prev ? this.prev.acc : initialValue
+			return callback(prevAcc, this.val)
+		}
+	}
+
+	function disposeIndex(index: number) {
+		const stop = indexEffects.get(index)
+		if (stop) {
+			stop()
+			indexEffects.delete(index)
+			untracked(() => {
+				Reflect.deleteProperty(indexToIntermediate as any, index)
+				Reflect.deleteProperty(result as any, index)
+			})
+		}
+	}
+
+	const mainEffect = effect(function scanMainEffect({ ascend }) {
+		const length = observedSource.length
+		const occurrenceCount = new Map<Input, number>()
+		let prev: Intermediate | undefined = undefined
+
+		for (let i = 0; i < length; i++) {
+			const val = FoolProof.get(observedSource as any, i, observedSource) as Input
+			
+			if (!(val && (typeof val === 'object' || typeof val === 'function' || typeof val === 'symbol'))) {
+				throw new Error('scan: items must be objects (WeakKey) for intermediate caching')
+			}
+
+			const count = occurrenceCount.get(val) ?? 0
+			occurrenceCount.set(val, count + 1)
+
+			let list = intermediaries.get(val)
+			if (!list) {
+				list = []
+				intermediaries.set(val, list)
+			}
+
+			let intermediate = list[count]
+			if (!intermediate) {
+				intermediate = reactive(new Intermediate(val, prev))
+				list[count] = intermediate
+			} else {
+				// Update the link. 
+				if (untracked(() => intermediate.prev) !== prev) {
+					intermediate.prev = prev
+				}
+			}
+
+			// Update the reactive mapping for this index
+			if (indexToIntermediate[i] !== intermediate) {
+				indexToIntermediate[i] = intermediate
+			}
+
+			// If we don't have an effect for this index yet, create one
+			if (!indexEffects.has(i)) {
+				ascend(() => {
+					const index = i
+					const stop = effect(function scanIndexSyncEffect() {
+						const inter = indexToIntermediate[index]
+						if (inter) {
+							const accValue = inter.acc
+							untracked(() => {
+								result[index] = accValue
+							})
+						}
+					})
+					indexEffects.set(index, stop)
+				})
+			}
+
+			prev = intermediate
+		}
+
+		// Cleanup trailing indices
+		for (const index of Array.from(indexEffects.keys())) {
+			if (index >= length) disposeIndex(index)
+		}
+		
+		// Ensure result length matches source length
+		untracked(() => {
+			if (result.length !== length) {
+				FoolProof.set(result as any, 'length', length, result)
+			}
+		})
+	})
+
+	return cleanedBy(result, () => {
+		mainEffect()
+		for (const stop of indexEffects.values()) stop()
+		indexEffects.clear()
+	}) as ScanResult<Output>
+}
+
+export function resolve<Output>(cb: () => Output[]): Output[] & { [cleanup]: ScopedCallback } {
+	const result = reactive([] as Output[])
+	return cleanedBy(result, effect(() => {
+		const source = cb()
+		if (result.length !== source.length) result.length = source.length
+		for (let i = 0; i < source.length; i++)
+			if (result[i] !== source[i]) result[i] = source[i]
+	}))
+}

package/src/reactive/change.ts

@@ -46,7 +46,7 @@ export function collectEffects(
 				for (const effect of deps) {
 					const runningChain = isRunning(effect)
 					if (runningChain) {
-						options.skipRunningEffect(effect, runningChain as any)
+						options.skipRunningEffect(effect)
 						continue
 					}
 					if (!effects.has(effect)) {
@@ -118,7 +118,7 @@ export function touchedOpaque(obj: any, evolution: Evolution, prop: any) {
 
 		const runningChain = isRunning(effect)
 		if (runningChain) {
-			options.skipRunningEffect(effect, runningChain as any)
+			options.skipRunningEffect(effect)
 			continue
 		}
 		effects.add(effect)

package/src/reactive/effect-context.ts

@@ -1,94 +1,18 @@
-import { effectParent, getRoot } from './registry'
-import { ReactiveError, type ScopedCallback } from './types'
-
-/**
- * Effect context stack for nested tracking (front = active, next = parent)
- */
-const stack: (ScopedCallback | undefined)[] = []
-export const effectStack = stack
-
-export function captureEffectStack() {
-	return stack.slice()
-}
-export function isRunning(effect: ScopedCallback): (ScopedCallback | undefined)[] | false {
-	const rootEffect = getRoot(effect)
-
-	// Check if the effect is directly in the stack
-	const rootIndex = stack.indexOf(rootEffect)
-	if (rootIndex !== -1) {
-		return stack.slice(0, rootIndex + 1).reverse()
-	}
-
-	// Check if any effect in the stack is a descendant of this effect
-	// (i.e., walk up the parent chain from each stack effect to see if we reach this effect)
-	for (let i = 0; i < stack.length; i++) {
-		const stackEffect = stack[i]
-		let current: ScopedCallback | undefined = stackEffect
-		const visited = new WeakSet<ScopedCallback>()
-		const ancestorChain: ScopedCallback[] = []
-		// TODO: That's perhaps a lot of computations for an `assert`
-		// Walk up the parent chain to find if this effect is an ancestor
-		while (current && !visited.has(current)) {
-			visited.add(current)
-			const currentRoot = getRoot(current)
-			ancestorChain.push(currentRoot)
-			if (currentRoot === rootEffect) {
-				// Found a descendant - build the full chain from ancestor to active
-				// The ancestorChain contains [descendant, parent, ..., ancestor] (walking up)
-				// We need [ancestor (effect), ..., parent, descendant, ...stack from descendant to active]
-				const chainFromAncestor = ancestorChain.reverse() // [ancestor, ..., descendant]
-				// Prepend the actual effect we're checking (in case current is a wrapper)
-				if (chainFromAncestor[0] !== rootEffect) {
-					chainFromAncestor.unshift(rootEffect)
-				}
-				// Append the rest of the stack from the descendant to the active effect
-				const stackFromDescendant = stack.slice(0, i + 1).reverse() // [descendant, ..., active]
-				// Remove duplicate descendant (it's both at end of chainFromAncestor and start of stackFromDescendant)
-				if (chainFromAncestor.length > 0 && stackFromDescendant.length > 0) {
-					stackFromDescendant.shift() // Remove duplicate descendant
-				}
-				return [...chainFromAncestor, ...stackFromDescendant]
-			}
-			current = effectParent.get(current)
-		}
-	}
-
-	return false
-}
-export function withEffectStack<T>(snapshot: (ScopedCallback | undefined)[], fn: () => T): T {
-	const previousStack = stack.slice()
-	assignStack(snapshot)
-	try {
-		return fn()
-	} finally {
-		assignStack(previousStack)
-	}
+import { tag } from '../utils'
+import { asyncZone, ZoneAggregator, ZoneHistory } from '../zone'
+import { getRoot } from './registry'
+import { type ScopedCallback } from './types'
+
+export const effectHistory = tag('effectHistory', new ZoneHistory<ScopedCallback>())
+tag('effectHistory.present', effectHistory.present)
+asyncZone.add(effectHistory)
+export const effectAggregator = tag('effectAggregator', new ZoneAggregator(effectHistory.present))
+
+export function isRunning(effect: ScopedCallback): boolean {
+	const root = getRoot(effect)
+	return effectHistory.some((e) => getRoot(e) === root)
 }
 
 export function getActiveEffect() {
-	return stack[0]
-}
-
-/**
- * Executes a function with a specific effect context
- * @param effect - The effect to use as context
- * @param fn - The function to execute
- * @param keepParent - Whether to keep the parent effect context
- * @returns The result of the function
- */
-export function withEffect<T>(effect: ScopedCallback | undefined, fn: () => T): T {
-
-	if (getRoot(effect) === getRoot(getActiveEffect())) return fn()
-	stack.unshift(effect)
-	try {
-		return fn()
-	} finally {
-		const recoveredEffect = stack.shift()
-		if (recoveredEffect !== effect) throw new ReactiveError('[reactive] Effect stack mismatch')
-	}
-}
-
-function assignStack(values: (ScopedCallback | undefined)[]) {
-	stack.length = 0
-	stack.push(...values)
-}
+	return effectHistory.present.active
+}