mutts 1.0.3 → 1.0.4

package/dist/reactive.d.ts

@@ -470,6 +470,7 @@ declare function addBatchCleanup(cleanup: ScopedCallback): void;
  * ```
  */
 declare const defer: typeof addBatchCleanup;
+declare function batch(effect: ScopedCallback | ScopedCallback[], immediate?: 'immediate'): any;
 /**
  * Decorator that makes methods atomic - batches all effects triggered within the method
  */
@@ -852,5 +853,5 @@ declare function isZoneEnabled(): boolean;
  */
 declare const profileInfo: any;
 
-export { ReactiveBase, ReactiveError, ReadOnlyError, Register, addBatchCleanup, atomic, biDi, buildReactivityGraph, cleanedBy, cleanup, deepWatch, defer, derived, effect, enableDevTools, getActiveEffect, getState, immutables, isDevtoolsEnabled, isNonReactive, isReactive, isZoneEnabled, mapped, memoize, organize, organized, profileInfo, project, reactive, options as reactiveOptions, reduced, register, registerEffectForDebug, registerNativeReactivity, registerObjectForDebug, root, setEffectName, setObjectName, setZoneEnabled, touched, touched1, trackEffect, unreactive, untracked, unwrap, watch };
+export { ReactiveBase, ReactiveError, ReadOnlyError, Register, addBatchCleanup, atomic, batch, biDi, buildReactivityGraph, cleanedBy, cleanup, deepWatch, defer, derived, effect, enableDevTools, getActiveEffect, getState, immutables, isDevtoolsEnabled, isNonReactive, isReactive, isZoneEnabled, mapped, memoize, organize, organized, profileInfo, project, reactive, options as reactiveOptions, reduced, register, registerEffectForDebug, registerNativeReactivity, registerObjectForDebug, root, setEffectName, setObjectName, setZoneEnabled, touched, touched1, trackEffect, unreactive, untracked, unwrap, watch };
 export type { DependencyAccess, DependencyFunction, Evolution, Memoizable, ReactivityGraph, ScopedCallback };

package/dist/reactive.esm.js

@@ -1,4 +1,4 @@
-export { L as ReactiveBase, U as ReactiveError, R as ReadOnlyError, Q as Register, j as addBatchCleanup, k as atomic, l as biDi, c as buildReactivityGraph, x as cleanedBy, y as cleanup, h as deepWatch, n as defer, z as derived, o as effect, e as enableDevTools, q as getActiveEffect, g as getState, F as immutables, i as isDevtoolsEnabled, G as isNonReactive, K as isReactive, V as isZoneEnabled, C as mapped, E as memoize, O as organize, P as organized, p as profileInfo, J as project, M as reactive, T as reactiveOptions, D as reduced, S as register, r as registerEffectForDebug, H as registerNativeReactivity, d as registerObjectForDebug, u as root, s as setEffectName, f as setObjectName, W as setZoneEnabled, t as touched, b as touched1, v as trackEffect, A as unreactive, w as untracked, N as unwrap, B as watch } from './chunks/index-DzUDtFc7.esm.js';
+export { M as ReactiveBase, V as ReactiveError, R as ReadOnlyError, S as Register, j as addBatchCleanup, k as atomic, l as batch, n as biDi, c as buildReactivityGraph, y as cleanedBy, z as cleanup, h as deepWatch, o as defer, A as derived, q as effect, e as enableDevTools, u as getActiveEffect, g as getState, G as immutables, i as isDevtoolsEnabled, H as isNonReactive, L as isReactive, W as isZoneEnabled, D as mapped, F as memoize, P as organize, Q as organized, p as profileInfo, K as project, N as reactive, U as reactiveOptions, E as reduced, T as register, r as registerEffectForDebug, J as registerNativeReactivity, d as registerObjectForDebug, v as root, s as setEffectName, f as setObjectName, X as setZoneEnabled, t as touched, b as touched1, w as trackEffect, B as unreactive, x as untracked, O as unwrap, C as watch } from './chunks/index-79Kk8D6e.esm.js';
 import './chunks/decorator-DqiszP7i.esm.js';
 import './indexable.esm.js';
 import './chunks/_tslib-Mzh1rNsX.esm.js';

package/dist/reactive.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var reactive = require('./chunks/index-HNVqPzjz.js');
+var reactive = require('./chunks/index-GRBSx0mB.js');
 require('./chunks/decorator-DLvrD0UF.js');
 require('./indexable.js');
 require('./chunks/_tslib-BgjropY9.js');
@@ -13,6 +13,7 @@ exports.ReadOnlyError = reactive.ReadOnlyError;
 exports.Register = reactive.Register;
 exports.addBatchCleanup = reactive.addBatchCleanup;
 exports.atomic = reactive.atomic;
+exports.batch = reactive.batch;
 exports.biDi = reactive.biDi;
 exports.buildReactivityGraph = reactive.buildReactivityGraph;
 exports.cleanedBy = reactive.cleanedBy;

package/dist/reactive.js.map

@@ -1 +1 @@
-{"version":3,"file":"reactive.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"reactive.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mutts",
   "description": "Modern UTility TS: A collection of TypeScript utilities",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",

package/src/reactive/effects.ts

@@ -835,15 +835,18 @@ export function batch(effect: ScopedCallback | ScopedCallback[], immediate?: 'im
 			addToBatch(effect[i], caller, immediate === 'immediate')
 		}
 		if (immediate) {
+			const firstReturn: { value?: any } = {}
 			// 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
 	} else {
@@ -935,67 +938,76 @@ export function batch(effect: ScopedCallback | ScopedCallback[], immediate?: 'im
 			// Execute in dependency order
 			const firstReturn: { value?: any } = {}
 			try {
-				while (batchQueue.all.size > 0) {
-					if (effectuatedRoots.length > options.maxEffectChain) {
-						const cycle = findCycleInChain(effectuatedRoots as any)
-						const trace = formatRoots(effectuatedRoots as any)
-						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])!
-										)
-									: [],
+				// 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 as any)
+							const trace = formatRoots(effectuatedRoots as any)
+							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
+							}
 						}
-						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 {
 				batchQueue = undefined
 				options.endChain()
 			}
 		}
+
 	}
 }
 

package/src/reactive/index.ts

@@ -13,6 +13,7 @@ export { deepWatch } from './deep-watch'
 export {
 	addBatchCleanup,
 	atomic,
+	batch, // TODO: Batch is now exported for testing purposes, though it shouldn't be - modify the tests to go through `atomic`
 	biDi,
 	defer,
 	effect,

package/src/reactive/proxy.ts

@@ -79,7 +79,11 @@ const reactiveHandlers = {
 			while (current && current !== Object.prototype) {
 				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)