mutts 1.0.3 → 1.0.4

package/dist/chunks/{index-DzUDtFc7.esm.js → index-79Kk8D6e.esm.js}

@@ -1953,16 +1953,20 @@ function batch(effect, immediate) {
             addToBatch(effect[i], caller, immediate === 'immediate');
         }
         if (immediate) {
+            const firstReturn = {};
             // Execute immediately (before batch returns)
             for (let i = 0; i < effect.length; i++) {
                 try {
-                    effect[i]();
+                    const rv = effect[i]();
+                    if (rv !== undefined && !('value' in firstReturn))
+                        firstReturn.value = rv;
                 }
                 finally {
                     const root = getRoot(effect[i]);
                     batchQueue.all.delete(root);
                 }
             }
+            return firstReturn.value;
         }
         // Otherwise, effects will be picked up in next executeNext() call
     }
@@ -2054,57 +2058,65 @@ function batch(effect, immediate) {
             // Execute in dependency order
             const firstReturn = {};
             try {
-                while (batchQueue.all.size > 0) {
-                    if (effectuatedRoots.length > options.maxEffectChain) {
-                        const cycle = findCycleInChain(effectuatedRoots);
-                        const trace = formatRoots(effectuatedRoots);
-                        const message = cycle
-                            ? `Max effect chain reached (cycle detected: ${formatRoots(cycle)})`
-                            : `Max effect chain reached (trace: ${trace})`;
-                        const queuedRoots = batchQueue ? Array.from(batchQueue.all.keys()) : [];
-                        const queued = queuedRoots.map((r) => r.name || '<anonymous>');
-                        const debugInfo = {
-                            code: ReactiveErrorCode.MaxDepthExceeded,
-                            effectuatedRoots,
-                            cycle,
-                            trace,
-                            maxEffectChain: options.maxEffectChain,
-                            queued: queued.slice(0, 50),
-                            queuedCount: queued.length,
-                            // Try to get causation for the last effect
-                            causalChain: effectuatedRoots.length > 0
-                                ? getTriggerChain(batchQueue.all.get(effectuatedRoots[effectuatedRoots.length - 1]))
-                                : [],
-                        };
-                        switch (options.maxEffectReaction) {
-                            case 'throw':
-                                throw new ReactiveError(`[reactive] ${message}`, debugInfo);
-                            case 'debug':
-                                // biome-ignore lint/suspicious/noDebugger: This is the whole point here
-                                debugger;
-                                throw new ReactiveError(`[reactive] ${message}`, debugInfo);
-                            case 'warn':
-                                options.warn(`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`);
-                                break;
+                // Outer loop: continue while there are effects OR cleanups pending.
+                // This ensures effects triggered by cleanups are not lost.
+                while (batchQueue.all.size > 0 || batchCleanups.size > 0) {
+                    // Inner loop: execute all pending effects
+                    while (batchQueue.all.size > 0) {
+                        if (effectuatedRoots.length > options.maxEffectChain) {
+                            const cycle = findCycleInChain(effectuatedRoots);
+                            const trace = formatRoots(effectuatedRoots);
+                            const message = cycle
+                                ? `Max effect chain reached (cycle detected: ${formatRoots(cycle)})`
+                                : `Max effect chain reached (trace: ${trace})`;
+                            const queuedRoots = batchQueue ? Array.from(batchQueue.all.keys()) : [];
+                            const queued = queuedRoots.map((r) => r.name || '<anonymous>');
+                            const debugInfo = {
+                                code: ReactiveErrorCode.MaxDepthExceeded,
+                                effectuatedRoots,
+                                cycle,
+                                trace,
+                                maxEffectChain: options.maxEffectChain,
+                                queued: queued.slice(0, 50),
+                                queuedCount: queued.length,
+                                // Try to get causation for the last effect
+                                causalChain: effectuatedRoots.length > 0
+                                    ? getTriggerChain(batchQueue.all.get(effectuatedRoots[effectuatedRoots.length - 1]))
+                                    : [],
+                            };
+                            switch (options.maxEffectReaction) {
+                                case 'throw':
+                                    throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                                case 'debug':
+                                    // biome-ignore lint/suspicious/noDebugger: This is the whole point here
+                                    debugger;
+                                    throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                                case 'warn':
+                                    options.warn(`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`);
+                                    break;
+                            }
+                        }
+                        const rv = executeNext(effectuatedRoots);
+                        // executeNext() returns null when batch is complete or cycle detected (throws error)
+                        // But functions can legitimately return null, so we check batchQueue.all.size instead
+                        if (batchQueue.all.size === 0) {
+                            // Batch complete
+                            break;
                         }
+                        // If executeNext() returned null but batch is not empty, it means a cycle was detected
+                        // and an error was thrown, so we won't reach here
+                        if (rv !== undefined && !('value' in firstReturn))
+                            firstReturn.value = rv;
+                        // Note: executeNext() already removed it from batchQueue, so we track by count
                     }
-                    const rv = executeNext(effectuatedRoots);
-                    // executeNext() returns null when batch is complete or cycle detected (throws error)
-                    // But functions can legitimately return null, so we check batchQueue.all.size instead
-                    if (batchQueue.all.size === 0) {
-                        // Batch complete
-                        break;
+                    // Process cleanups. If they trigger new effects, the outer loop will catch them.
+                    if (batchCleanups.size > 0) {
+                        const cleanups = Array.from(batchCleanups);
+                        batchCleanups.clear();
+                        for (const cleanup of cleanups)
+                            cleanup();
                     }
-                    // If executeNext() returned null but batch is not empty, it means a cycle was detected
-                    // and an error was thrown, so we won't reach here
-                    if (rv !== undefined && !('value' in firstReturn))
-                        firstReturn.value = rv;
-                    // Note: executeNext() already removed it from batchQueue, so we track by count
                 }
-                const cleanups = Array.from(batchCleanups);
-                batchCleanups.clear();
-                for (const cleanup of cleanups)
-                    cleanup();
                 return firstReturn.value;
             }
             finally {
@@ -2864,7 +2876,11 @@ const reactiveHandlers = {
                 dependant(current, prop);
                 if (Object.hasOwn(current, prop))
                     break;
-                current = reactiveObject(Object.getPrototypeOf(current));
+                let next = reactiveObject(Object.getPrototypeOf(current));
+                if (next === current) {
+                    next = reactiveObject(Object.getPrototypeOf(unwrap(current)));
+                }
+                current = next;
             }
         }
         const value = ReflectGet(obj, prop, receiver);
@@ -4837,5 +4853,5 @@ const profileInfo = {
     nonReactiveObjects,
 };
 
-export { unreactive as A, watch as B, mapped as C, reduced as D, memoize as E, immutables as F, isNonReactive as G, registerNativeReactivity as H, IterableWeakMap as I, project as J, isReactive as K, ReactiveBase as L, reactive as M, unwrap as N, organize as O, organized as P, Register as Q, ReadOnlyError as R, register as S, options as T, ReactiveError as U, isZoneEnabled as V, setZoneEnabled as W, IterableWeakSet as a, touched1 as b, buildReactivityGraph as c, registerObjectForDebug as d, enableDevTools as e, setObjectName as f, getState as g, deepWatch as h, isDevtoolsEnabled as i, addBatchCleanup as j, atomic as k, biDi as l, mixin as m, defer as n, effect as o, profileInfo as p, getActiveEffect as q, registerEffectForDebug as r, setEffectName as s, touched as t, root as u, trackEffect as v, untracked as w, cleanedBy as x, cleanup as y, derived as z };
-//# sourceMappingURL=index-DzUDtFc7.esm.js.map
+export { derived as A, unreactive as B, watch as C, mapped as D, reduced as E, memoize as F, immutables as G, isNonReactive as H, IterableWeakMap as I, registerNativeReactivity as J, project as K, isReactive as L, ReactiveBase as M, reactive as N, unwrap as O, organize as P, organized as Q, ReadOnlyError as R, Register as S, register as T, options as U, ReactiveError as V, isZoneEnabled as W, setZoneEnabled as X, IterableWeakSet as a, touched1 as b, buildReactivityGraph as c, registerObjectForDebug as d, enableDevTools as e, setObjectName as f, getState as g, deepWatch as h, isDevtoolsEnabled as i, addBatchCleanup as j, atomic as k, batch as l, mixin as m, biDi as n, defer as o, profileInfo as p, effect as q, registerEffectForDebug as r, setEffectName as s, touched as t, getActiveEffect as u, root as v, trackEffect as w, untracked as x, cleanedBy as y, cleanup as z };
+//# sourceMappingURL=index-79Kk8D6e.esm.js.map