mutts 1.0.3 → 1.0.5

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

@@ -352,6 +352,10 @@ const prototypeForwarding = Symbol('prototype-forwarding');
  * Symbol representing all properties in reactive tracking
  */
 const allProps = Symbol('all-props');
+/**
+ * Symbol for accessing projection information on reactive objects
+ */
+const projectionInfo = Symbol('projection-info');
 // Symbol to mark functions with their root function
 const rootFunction = Symbol('root-function');
 /**
@@ -426,6 +430,12 @@ const options = {
      * @default 100
      */
     maxEffectChain: 100,
+    /**
+     * Maximum number of times an effect can be triggered by the same cause in a single batch
+     * Used to detect aggressive re-computation or infinite loops
+     * @default 10
+     */
+    maxTriggerPerBatch: 10,
     /**
      * Debug purpose: maximum effect reaction (like call stack max depth)
      * Used to prevent infinite loops
@@ -1258,6 +1268,50 @@ function formatRoots(roots, limit = 20) {
     const end = names.slice(-10);
     return `${start.join(' → ')} ... (${names.length - 15} more) ... ${end.join(' → ')}`;
 }
+// Nested map structure for efficient counting and batch cleanup
+// batchId -> effect root -> obj -> prop -> count
+let activationRegistry;
+const activationLog = new Array(100);
+function getActivationLog() {
+    return activationLog;
+}
+function recordActivation(effect, obj, evolution, prop) {
+    const root = getRoot(effect);
+    if (!activationRegistry)
+        return;
+    let effectData = activationRegistry.get(root);
+    if (!effectData) {
+        effectData = new Map();
+        activationRegistry.set(root, effectData);
+    }
+    let objData = effectData.get(obj);
+    if (!objData) {
+        objData = new Map();
+        effectData.set(obj, objData);
+    }
+    const count = (objData.get(prop) ?? 0) + 1;
+    objData.set(prop, count);
+    // Keep a limited history for diagnostics
+    activationLog.unshift({
+        effect,
+        obj,
+        evolution,
+        prop,
+    });
+    activationLog.pop();
+    if (count >= options.maxTriggerPerBatch) {
+        const effectName = root?.name || 'anonymous';
+        const message = `Aggressive trigger detected: effect "${effectName}" triggered ${count} times in the batch by the same cause.`;
+        if (options.maxEffectReaction === 'throw') {
+            throw new ReactiveError(message, {
+                code: ReactiveErrorCode.MaxReactionExceeded,
+                count,
+                effect: effectName,
+            });
+        }
+        options.warn(`[reactive] ${message}`);
+    }
+}
 /**
  * Registers a debug callback that is called when the current effect is triggered by a dependency change
  *
@@ -1547,6 +1601,9 @@ function cleanupEffectFromGraph(effect) {
 // Track currently executing effects to prevent re-execution
 // These are all the effects triggered under `activeEffect`
 let batchQueue;
+function hasBatched(effect) {
+    return batchQueue?.all.has(getRoot(effect));
+}
 const batchCleanups = new Set();
 /**
  * Computes and caches in-degrees for all effects in the batch
@@ -1953,21 +2010,29 @@ 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
     }
     else {
         // New batch - initialize
+        if (!activationRegistry)
+            activationRegistry = new Map();
+        else
+            throw new Error('Batch already in progress');
         options.beginChain(roots);
         batchQueue = {
             all: new Map(),
@@ -2046,6 +2111,7 @@ function batch(effect, immediate) {
                 return firstReturn.value;
             }
             finally {
+                activationRegistry = undefined;
                 batchQueue = undefined;
                 options.endChain();
             }
@@ -2054,60 +2120,69 @@ 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 {
+                activationRegistry = undefined;
                 batchQueue = undefined;
                 options.endChain();
             }
@@ -2477,7 +2552,11 @@ function collectEffects(obj, evolution, effects, objectWatchers, ...keyChains) {
                         options.skipRunningEffect(effect, runningChain);
                         continue;
                     }
-                    effects.add(effect);
+                    if (!effects.has(effect)) {
+                        effects.add(effect);
+                        if (!hasBatched(effect))
+                            recordActivation(effect, obj, evolution, key);
+                    }
                     const trackers = effectTrackers.get(effect);
                     recordTriggerLink(sourceEffect, effect, obj, key, evolution);
                     if (trackers) {
@@ -2545,6 +2624,7 @@ function touchedOpaque(obj, evolution, prop) {
             continue;
         }
         effects.add(effect);
+        recordActivation(effect, obj, evolution, prop);
         const trackers = effectTrackers.get(effect);
         recordTriggerLink(sourceEffect, effect, obj, prop, evolution);
         if (trackers) {
@@ -2864,7 +2944,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);
@@ -3329,7 +3413,6 @@ function* makeReactiveEntriesIterator(iterator) {
 const native$2 = Symbol('native');
 const isArray = Array.isArray;
 Array.isArray = ((value) => isArray(value) ||
-    // biome-ignore lint/suspicious/useIsArray: We are defining it
     (value &&
         typeof value === 'object' &&
         prototypeForwarding in value &&
@@ -4225,6 +4308,17 @@ function register(keyFn, initial) {
     return new RegisterClass(keyFn, initial);
 }
 
+/**
+ * Maps projection effects (item effects) to their projection context
+ */
+const effectProjectionMetadata = new WeakMap();
+/**
+ * Returns the projection context of the currently running effect, if any.
+ */
+function getActiveProjection() {
+    const active = getActiveEffect();
+    return active ? effectProjectionMetadata.get(active) : undefined;
+}
 function defineAccessValue(access) {
     Object.defineProperty(access, 'value', {
         get: access.get,
@@ -4233,7 +4327,15 @@ function defineAccessValue(access) {
         enumerable: true,
     });
 }
-function makeCleanup(target, effectMap, onDispose) {
+function makeCleanup(target, effectMap, onDispose, metadata) {
+    if (metadata) {
+        Object.defineProperty(target, projectionInfo, {
+            value: metadata,
+            writable: false,
+            enumerable: false,
+            configurable: true,
+        });
+    }
     return cleanedBy(target, () => {
         onDispose();
         for (const stop of effectMap.values())
@@ -4256,6 +4358,8 @@ function projectArray(source, apply) {
             Reflect.deleteProperty(target, index);
         }
     }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
     const cleanupLength = effect(function projectArrayLengthEffect({ ascend }) {
         const length = observedSource.length;
         normalizeTargetLength(length);
@@ -4278,6 +4382,14 @@ function projectArray(source, apply) {
                     const produced = apply(accessBase, target);
                     target[index] = produced;
                 });
+                setEffectName(stop, `project[${depth}]:${index}`);
+                effectProjectionMetadata.set(stop, {
+                    source: observedSource,
+                    key: index,
+                    target,
+                    depth,
+                    parent,
+                });
                 indexEffects.set(i, stop);
             });
         }
@@ -4285,7 +4397,13 @@ function projectArray(source, apply) {
             if (index >= length)
                 disposeIndex(index);
     });
-    return makeCleanup(target, indexEffects, () => cleanupLength());
+    return makeCleanup(target, indexEffects, () => cleanupLength(), {
+        source: observedSource,
+        target,
+        apply,
+        depth,
+        parent,
+    });
 }
 function projectRegister(source, apply) {
     const observedSource = reactive(source);
@@ -4300,6 +4418,8 @@ function projectRegister(source, apply) {
             target.delete(key);
         }
     }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
     const cleanupKeys = effect(function projectRegisterEffect({ ascend }) {
         const keys = new Set();
         for (const key of observedSource.mapKeys())
@@ -4324,6 +4444,14 @@ function projectRegister(source, apply) {
                     const produced = apply(accessBase, target);
                     target.set(key, produced);
                 });
+                setEffectName(stop, `project[${depth}]:${String(key)}`);
+                effectProjectionMetadata.set(stop, {
+                    source: observedSource,
+                    key,
+                    target,
+                    depth,
+                    parent,
+                });
                 keyEffects.set(key, stop);
             });
         }
@@ -4331,7 +4459,13 @@ function projectRegister(source, apply) {
             if (!keys.has(key))
                 disposeKey(key);
     });
-    return makeCleanup(target, keyEffects, () => cleanupKeys());
+    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+        source: observedSource,
+        target,
+        apply,
+        depth,
+        parent,
+    });
 }
 function projectRecord(source, apply) {
     const observedSource = reactive(source);
@@ -4345,6 +4479,8 @@ function projectRecord(source, apply) {
             Reflect.deleteProperty(target, key);
         }
     }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
     const cleanupKeys = effect(function projectRecordEffect({ ascend }) {
         const keys = new Set();
         for (const key in observedSource)
@@ -4370,6 +4506,14 @@ function projectRecord(source, apply) {
                     const produced = apply(accessBase, target);
                     target[sourceKey] = produced;
                 });
+                setEffectName(stop, `project[${depth}]:${String(key)}`);
+                effectProjectionMetadata.set(stop, {
+                    source: observedSource,
+                    key,
+                    target,
+                    depth,
+                    parent,
+                });
                 keyEffects.set(key, stop);
             });
         }
@@ -4377,7 +4521,13 @@ function projectRecord(source, apply) {
             if (!keys.has(key))
                 disposeKey(key);
     });
-    return makeCleanup(target, keyEffects, () => cleanupKeys());
+    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+        source: observedSource,
+        target,
+        apply,
+        depth,
+        parent,
+    });
 }
 function projectMap(source, apply) {
     const observedSource = reactive(source);
@@ -4392,6 +4542,8 @@ function projectMap(source, apply) {
             target.delete(key);
         }
     }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
     const cleanupKeys = effect(function projectMapEffect({ ascend }) {
         const keys = new Set();
         for (const key of observedSource.keys())
@@ -4416,6 +4568,14 @@ function projectMap(source, apply) {
                     const produced = apply(accessBase, target);
                     target.set(key, produced);
                 });
+                setEffectName(stop, `project[${depth}]:${String(key)}`);
+                effectProjectionMetadata.set(stop, {
+                    source: observedSource,
+                    key,
+                    target,
+                    depth,
+                    parent,
+                });
                 keyEffects.set(key, stop);
             });
         }
@@ -4423,7 +4583,13 @@ function projectMap(source, apply) {
             if (!keys.has(key))
                 disposeKey(key);
     });
-    return makeCleanup(target, keyEffects, () => cleanupKeys());
+    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+        source: observedSource,
+        target,
+        apply,
+        depth,
+        parent,
+    });
 }
 function projectCore(source, apply) {
     if (Array.isArray(source))
@@ -4571,7 +4737,7 @@ class ReactiveWeakMap {
         Object.defineProperties(this, {
             [native$1]: { value: original },
             [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
+            content: { value: Symbol('WeakMapContent') },
             [Symbol.toStringTag]: { value: 'ReactiveWeakMap' },
         });
     }
@@ -4611,7 +4777,7 @@ class ReactiveMap {
         Object.defineProperties(this, {
             [native$1]: { value: original },
             [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
+            content: { value: Symbol('MapContent') },
             [Symbol.toStringTag]: { value: 'ReactiveMap' },
         });
     }
@@ -4706,7 +4872,7 @@ class ReactiveWeakSet {
         Object.defineProperties(this, {
             [native]: { value: original },
             [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
+            content: { value: Symbol('WeakSetContent') },
             [Symbol.toStringTag]: { value: 'ReactiveWeakSet' },
         });
     }
@@ -4741,7 +4907,7 @@ class ReactiveSet {
         Object.defineProperties(this, {
             [native]: { value: original },
             [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
+            content: { value: Symbol('SetContent') },
             [Symbol.toStringTag]: { value: 'ReactiveSet' },
         });
     }
@@ -4837,5 +5003,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 { cleanup as A, derived as B, unreactive as C, watch as D, mapped as E, reduced as F, memoize as G, immutables as H, IterableWeakMap as I, isNonReactive as J, registerNativeReactivity as K, getActiveProjection as L, project as M, isReactive as N, ReactiveBase as O, reactive as P, unwrap as Q, ReadOnlyError as R, organize as S, organized as T, Register as U, register as V, options as W, ReactiveError as X, isZoneEnabled as Y, setZoneEnabled as Z, 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, getActivationLog as u, getActiveEffect as v, root as w, trackEffect as x, untracked as y, cleanedBy as z };
+//# sourceMappingURL=index-qiWwozOc.esm.js.map