mutts 1.0.3 → 1.0.4

package/dist/chunks/{index-HNVqPzjz.js → index-GRBSx0mB.js}

@@ -1955,16 +1955,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
     }
@@ -2056,57 +2060,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 {
@@ -2866,7 +2878,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 = decorator.ReflectGet(obj, prop, receiver);
@@ -4847,6 +4863,7 @@ exports.ReadOnlyError = ReadOnlyError;
 exports.Register = Register;
 exports.addBatchCleanup = addBatchCleanup;
 exports.atomic = atomic;
+exports.batch = batch;
 exports.biDi = biDi;
 exports.buildReactivityGraph = buildReactivityGraph;
 exports.cleanedBy = cleanedBy;
@@ -4888,4 +4905,4 @@ exports.unreactive = unreactive;
 exports.untracked = untracked;
 exports.unwrap = unwrap;
 exports.watch = watch;
-//# sourceMappingURL=index-HNVqPzjz.js.map
+//# sourceMappingURL=index-GRBSx0mB.js.map