mutts 1.0.5 → 1.0.7

package/src/reactive/change.ts

@@ -3,7 +3,7 @@ import { bubbleUpChange, objectsWithDeepWatchers } from './deep-watch-state'
 import { getActiveEffect, isRunning } from './effect-context'
 import { batch, effectTrackers, hasBatched, opaqueEffects, recordActivation } from './effects'
 import { unwrap } from './proxy-state'
-import { watchers } from './tracking'
+import { watchers } from './registry'
 import { allProps, type Evolution, options, type ScopedCallback, type State } from './types'
 
 const states = new WeakMap<object, State>()
@@ -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/debug.ts

@@ -5,7 +5,7 @@
  * - Provides graph data for tooling (DevTools panel, etc.)
  */
 
-import { effectParent, effectToReactiveObjects, getRoot } from './tracking'
+import { effectParent, effectToReactiveObjects, getRoot } from './registry'
 import { allProps, type Evolution, options, type ScopedCallback } from './types'
 
 const EXTERNAL_SOURCE = Symbol('external-source')

package/src/reactive/deep-touch.ts

@@ -3,7 +3,7 @@ import { bubbleUpChange, objectsWithDeepWatchers } from './deep-watch-state'
 import { batch } from './effects'
 import { isNonReactive } from './non-reactive-state'
 import { unwrap } from './proxy-state'
-import { effectParent, watchers } from './tracking'
+import { effectParent, watchers } from './registry'
 import { allProps, type Evolution, options, type ScopedCallback } from './types'
 
 function isObject(value: any): value is object {

package/src/reactive/deep-watch.ts

@@ -6,7 +6,7 @@ import {
 import { effect } from './effects'
 import { isNonReactive } from './non-reactive-state'
 import { reactive, unwrap } from './proxy'
-import { markWithRoot } from './tracking'
+import { markWithRoot } from './registry'
 import { options, type ScopedCallback } from './types'
 
 function isObject(value: any): value is object {

package/src/reactive/effect-context.ts

@@ -1,94 +1,18 @@
-import { effectParent, getRoot } from './tracking'
-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(new ZoneHistory<ScopedCallback>(), 'effectHistory')
+tag(effectHistory.present, 'effectHistory.present')
+asyncZone.add(effectHistory)
+export const effectAggregator = tag(new ZoneAggregator(effectHistory.present), 'effectAggregator')
+
+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 {
-	// console.log('[Mutts] withEffect', effect ? 'Active' : 'NULL');
-	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
+}