mutts 1.0.13 → 1.0.14

package/dist/chunks/{index-XsYTUhHx.esm.js → index-CAWVZL7P.esm.js}

@@ -1,4 +1,4 @@
-import { u as decorator, p as captioned, a4 as options, y as effect, af as markWithRoot, W as link, F as flavored, a7 as tag, a3 as reactive, a9 as touched1, T as isReactive, a8 as touched, K as getState, ag as dependant, J as getActiveEffect, ah as getEffectNode, ai as chainExternalReason, aj as keysOf, ak as objectsWithDeepWatchers, al as effectToDeepWatchedObjects, ab as untracked, am as deepWatchers, P as isNonReactive, ac as unwrap, an as registerDeepWatcher, _ as named, ao as rootFunctionSymbol, a2 as proxyToObject, ap as getRoot, v as deepCompare, aq as optionCall, a6 as root, ar as FoolProof, E as flavorOptions, as as effectHistory, q as captured, at as unreactiveProperties, g as addUnreactiveProps, au as __runInitializers, av as __esDecorate, n as atomic, aw as batch, ax as contentRef, ay as notifyPropertyChange, az as metaProtos, aA as wrapProtos, aB as objectParents, aC as watchers, aD as effectToReactiveObjects, $ as objectToProxy } from './proxy-BtmPFjSr.esm.js';
+import { u as decorator, p as captioned, aa as options, y as effect, ap as markWithRoot, Y as link, F as flavored, af as tag, a9 as reactive, ai as touched1, U as isReactive, ah as touched, K as getState, aq as dependant, J as getActiveEffect, ar as getEffectNode, as as chainExternalReason, at as keysOf, au as objectsWithDeepWatchers, av as effectToDeepWatchedObjects, ak as untracked, aw as deepWatchers, Q as isNonReactive, al as unwrap, ax as registerDeepWatcher, a2 as named, ay as rootFunctionSymbol, a8 as proxyToObject, az as getRoot, aA as inertDepth, v as deepCompare, aB as optionCall, ad as root, aC as FoolProof, E as flavorOptions, aD as effectHistory, q as captured, aE as unreactiveProperties, g as addUnreactiveProps, aF as __runInitializers, aG as __esDecorate, n as atomic, aH as contentRef, aI as notifyPropertyChange, aJ as metaProtos, aK as wrapProtos, aL as objectParents, aM as watchers, aN as effectToReactiveObjects, a3 as objectToProxy } from './proxy-C2lnvvbx.esm.js';
 
 // Integrated with `using` statement via Symbol.dispose
 const fr = new FinalizationRegistry((f) => f());
@@ -893,22 +893,26 @@ const lift = captioned(function lift(cb) {
  */
 function morphArray(source, fn, options) {
     if (typeof source !== 'function' && !isReactive(source) && options?.pure === true) {
-        return source.map((i) => fn(i));
+        return source.map((i) => fn(i, { index: 0 }));
     }
     let track;
     const itemEffects = new Map();
     const cache = tag(`morph:${fn.name || 'anonymous'}`, []);
     let input = [];
+    function currentCleanupReason() {
+        const activeEffect = getActiveEffect();
+        if (!activeEffect)
+            return undefined;
+        const node = getEffectNode(activeEffect);
+        return node.currentReason;
+    }
+    function stopEntry(entry) {
+        entry.stop(chainExternalReason({ type: 'stopped', chain: currentCleanupReason() }));
+    }
     function stopItem(key) {
         const entry = itemEffects.get(key);
         if (entry) {
-            const activeEffect = getActiveEffect();
-            let chain;
-            if (activeEffect) {
-                const node = getEffectNode(activeEffect);
-                chain = node.currentReason;
-            }
-            entry.stop(chainExternalReason({ type: 'stopped', chain }));
+            stopEntry(entry);
             itemEffects.delete(key);
         }
     }
@@ -916,15 +920,14 @@ function morphArray(source, fn, options) {
         const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(input));
         if (isPure) {
             track(() => {
-                cache[key] = fn(input);
+                cache[key] = fn(input, { index: key });
             });
         }
         else {
-            const indexRef = { value: key };
+            const position = reactive({ index: key });
             const stop = track(() => effect.opaque `morph:${fn.name}:${key}`((access) => {
-                cache[indexRef.value] = fn(input, access);
-                return (reason) => {
-                    delete cache[indexRef.value];
+                if (access.reaction) {
+                    delete cache[position.index];
                     touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
                     const activeEffect = getActiveEffect();
                     let chain;
@@ -934,12 +937,16 @@ function morphArray(source, fn, options) {
                     }
                     stop?.({
                         type: 'invalidate',
-                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        cause: chainExternalReason(!access.reaction || access.reaction === true
+                            ? { type: 'stopped', chain }
+                            : access.reaction),
                         chain: chainExternalReason(chain),
                     });
-                };
+                }
+                else
+                    cache[position.index] = fn(input, position, access);
             }));
-            itemEffects.set(key, { stop, index: indexRef });
+            itemEffects.set(key, { stop, position });
         }
     }
     const proxy = reactive(cache, {
@@ -960,35 +967,59 @@ function morphArray(source, fn, options) {
         const newInput = [...(typeof source === 'function' ? source() : source)];
         const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
         if (diffs.length > 0) {
+            const reusable = new Map();
+            for (const [index, entry] of itemEffects) {
+                const value = input[index];
+                const entries = reusable.get(value);
+                if (entries)
+                    entries.push({ index, entry });
+                else
+                    reusable.set(value, [{ index, entry }]);
+            }
+            const nextEffects = new Map();
+            const reused = new Set();
+            const nextCache = new Map();
+            for (let index = 0; index < newInput.length; index++) {
+                const entries = reusable.get(newInput[index]);
+                const reusedEntry = entries?.shift();
+                if (!reusedEntry)
+                    continue;
+                const { index: previousIndex, entry } = reusedEntry;
+                reused.add(previousIndex);
+                nextEffects.set(index, entry);
+                if (entry.position.index !== index)
+                    entry.position.index = index;
+                else if (Object.hasOwn(cache, previousIndex))
+                    nextCache.set(index, cache[previousIndex]);
+            }
+            for (const [index, entry] of itemEffects) {
+                if (!reused.has(index))
+                    stopEntry(entry);
+            }
+            itemEffects.clear();
+            for (const [index, entry] of nextEffects)
+                itemEffects.set(index, entry);
+            const previousLength = cache.length;
+            cache.length = newInput.length;
+            for (let i = 0; i < Math.max(previousLength, newInput.length); i++)
+                delete cache[i];
+            for (const [index, value] of nextCache)
+                cache[index] = value;
+            const eagerIndices = new Set();
             for (const diff of diffs) {
-                // Stop items in removed range
-                for (let i = diff.indexA; i < diff.indexA + diff.sliceA.length; i++)
-                    stopItem(i);
-                // Shift existing itemEffects in the Map to match the new indices
-                const shift = diff.sliceB.length - diff.sliceA.length;
-                if (shift !== 0) {
-                    // We need to move entries in the Map.
-                    const entries = Array.from(itemEffects.entries()).sort((a, b) => a[0] - b[0]);
-                    // Remove entries that will be shifted
-                    for (const [idx, _entry] of entries) {
-                        if (idx >= diff.indexA + diff.sliceA.length) {
-                            itemEffects.delete(idx);
-                        }
-                    }
-                    // Re-add them with shifted indices
-                    for (const [idx, entry] of entries) {
-                        if (idx >= diff.indexA + diff.sliceA.length) {
-                            const newIdx = idx + shift;
-                            entry.index.value = newIdx;
-                            itemEffects.set(newIdx, entry);
-                        }
-                    }
-                }
-                // Splice the cache
-                cache.splice(diff.indexA, diff.sliceA.length, ...new Array(diff.sliceB.length).fill(undefined));
-                // Make holes for lazy computation
-                for (let i = diff.indexA; i < diff.indexA + diff.sliceB.length; i++)
-                    delete cache[i];
+                const max = Math.max(diff.sliceA.length, diff.sliceB.length);
+                for (let i = 0; i < max; i++)
+                    eagerIndices.add(diff.indexA + i);
+            }
+            for (const index of eagerIndices) {
+                if (index < 0 || index >= newInput.length || Object.hasOwn(cache, index))
+                    continue;
+                const value = newInput[index];
+                const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(value));
+                if (isPure)
+                    continue;
+                stopItem(index);
+                computeItem(index, value);
             }
             const invalidates = new Set([keysOf]);
             if (input.length !== newInput.length)
@@ -1422,6 +1453,9 @@ function memoizeFunction(fn, opts) {
         for (const arg of args) {
             node = getBranch(node, arg);
         }
+        if (inertDepth > 0) {
+            return fn.apply(this, args);
+        }
         dependant(node, 'memoize');
         if ('result' in node) {
             if (options.onMemoizationDiscrepancy) {
@@ -2060,14 +2094,28 @@ let ReactiveArrayWrapper = (() => {
                 }, thisArg);
             }
             includes(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.includes(unwrap(searchElement), fromIndex)
-                    : super.includes(unwrap(searchElement));
+                const target = unwrap(searchElement);
+                const length = this.length;
+                let start = fromIndex ?? 0;
+                if (start < 0)
+                    start = Math.max(length + start, 0);
+                for (let i = start; i < length; i++) {
+                    const value = unwrap(this[i]);
+                    if (value === target)
+                        return true;
+                }
+                return false;
             }
             indexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.indexOf(unwrap(searchElement), fromIndex)
-                    : super.indexOf(unwrap(searchElement));
+                const target = unwrap(searchElement);
+                const length = this.length;
+                let start = fromIndex ?? 0;
+                if (start < 0)
+                    start = Math.max(length + start, 0);
+                for (let i = start; i < length; i++)
+                    if (unwrap(this[i]) === target)
+                        return i;
+                return -1;
             }
             join(separator) {
                 return super.join(separator);
@@ -2077,9 +2125,17 @@ let ReactiveArrayWrapper = (() => {
                 return super.keys();
             }
             lastIndexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.lastIndexOf(unwrap(searchElement), fromIndex)
-                    : super.lastIndexOf(unwrap(searchElement));
+                const target = unwrap(searchElement);
+                const length = this.length;
+                let start = fromIndex ?? length - 1;
+                if (start < 0)
+                    start = length + start;
+                if (start >= length)
+                    start = length - 1;
+                for (let i = start; i >= 0; i--)
+                    if (unwrap(this[i]) === target)
+                        return i;
+                return -1;
             }
             map(callbackfn, thisArg) {
                 return reactive(super.map((v, i, a) => unwrap(callbackfn.call(thisArg, reactive(v), i, a)), thisArg));
@@ -2119,13 +2175,25 @@ let ReactiveArrayWrapper = (() => {
                 return super.sort(wrappedCompare);
             }
             splice(start, deleteCount, ...items) {
+                const length = this.length;
+                const normalizedStart = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+                const actualDeleteCount = arguments.length === 1
+                    ? length - normalizedStart
+                    : Math.min(Math.max(deleteCount, 0), length - normalizedStart);
+                const structural = actualDeleteCount > 0 || items.length > 0;
+                let result;
                 if (arguments.length > 2)
-                    return reactive(super.splice(start, deleteCount, ...items.map(unwrap)));
-                if (arguments.length === 2)
-                    return reactive(super.splice(start, deleteCount));
-                if (arguments.length === 1)
-                    return reactive(super.splice(start));
-                return reactive([]);
+                    result = super.splice(start, deleteCount, ...items.map(unwrap));
+                else if (arguments.length === 2)
+                    result = super.splice(start, deleteCount);
+                else if (arguments.length === 1)
+                    result = super.splice(start);
+                else
+                    result = [];
+                if (structural && this.length === length) {
+                    touched(this, { type: 'set', prop: 'length' }, ['length']);
+                }
+                return reactive(result);
             }
             unshift(...items) {
                 return super.unshift(...items.map(unwrap));
@@ -2180,6 +2248,12 @@ let ReactiveArrayWrapper = (() => {
         _a;
 })();
 
+// These abstract classes are prototype tables for the reactive proxy, not classes
+// that are instantiated directly. `this` is the original Map/WeakMap target when
+// a method is reached through the proxy meta-prototype path, so calls like
+// `this.get()` or `this.entries()` intentionally re-enter the proxy machinery.
+// Do not mechanically rewrite them to `super.*` as if these were real subclass
+// instances; that would bypass parts of the designed reactive dispatch.
 /**
  * Reactive wrapper around JavaScript's WeakMap class
  * Only tracks individual key operations, no size tracking (WeakMap limitation)
@@ -2228,10 +2302,8 @@ class ReactiveMap extends Map {
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
             // Clear triggers all effects since all keys are affected
-            batch(() => {
-                touched1(this, evolution, 'size');
-                touched(contentRef(this), evolution);
-            });
+            touched1(this, evolution, 'size');
+            touched(contentRef(this), evolution);
         }
     }
     entries() {
@@ -2269,10 +2341,8 @@ class ReactiveMap extends Map {
         const result = super.delete(key);
         if (hadKey) {
             const evolution = { type: 'del', prop: key };
-            batch(() => {
-                touched1(contentRef(this), evolution, key);
-                touched1(this, evolution, 'size');
-            });
+            touched1(contentRef(this), evolution, key);
+            touched1(this, evolution, 'size');
         }
         return result;
     }
@@ -2290,17 +2360,21 @@ class ReactiveMap extends Map {
         const reactiveValue = reactive(value);
         super.set(key, reactiveValue);
         if (!hadKey || oldValue !== reactiveValue) {
-            batch(() => {
-                notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
-                // Also notify size change for Map (WeakMap doesn't track size)
-                const evolution = { type: hadKey ? 'set' : 'add', prop: key };
-                touched1(this, evolution, 'size');
-            });
+            notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
+            // Also notify size change for Map (WeakMap doesn't track size)
+            const evolution = { type: hadKey ? 'set' : 'add', prop: key };
+            touched1(this, evolution, 'size');
         }
         return this;
     }
 }
 
+// These abstract classes are prototype tables for the reactive proxy, not classes
+// that are instantiated directly. `this` is the original Set/WeakSet target when
+// a method is reached through the proxy meta-prototype path, so calls like
+// `this.has()` or `this.entries()` intentionally re-enter the proxy machinery.
+// Do not mechanically rewrite them to `super.*` as if these were real subclass
+// instances; that would bypass parts of the designed reactive dispatch.
 /**
  * Reactive wrapper around JavaScript's WeakSet class
  * Only tracks individual value operations, no size tracking (WeakSet limitation)
@@ -2345,10 +2419,8 @@ class ReactiveSet extends Set {
         if (!had) {
             const evolution = { type: 'add', prop: reactiveValue };
             // touch for value-specific and aggregate dependencies
-            batch(() => {
-                touched1(contentRef(this), evolution, reactiveValue);
-                touched1(this, evolution, 'size');
-            });
+            touched1(contentRef(this), evolution, reactiveValue);
+            touched1(this, evolution, 'size');
         }
         return this;
     }
@@ -2357,10 +2429,8 @@ class ReactiveSet extends Set {
         super.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
-            batch(() => {
-                touched1(this, evolution, 'size');
-                touched(contentRef(this), evolution);
-            });
+            touched1(this, evolution, 'size');
+            touched(contentRef(this), evolution);
         }
     }
     delete(value) {
@@ -2368,10 +2438,8 @@ class ReactiveSet extends Set {
         const res = super.delete(value);
         if (had) {
             const evolution = { type: 'del', prop: value };
-            batch(() => {
-                touched1(contentRef(this), evolution, value);
-                touched1(this, evolution, 'size');
-            });
+            touched1(contentRef(this), evolution, value);
+            touched1(this, evolution, 'size');
         }
         return res;
     }
@@ -2659,7 +2727,7 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.13";
+var version$1 = "1.0.14";
 var pkg = {
 	version: version$1};
 
@@ -2697,4 +2765,4 @@ if (globalScope) {
 }
 
 export { ArrayReadForward as A, unreactive as B, watch as C, Destroyable as D, Eventful as E, when as F, Indexable as I, DestructionError as a, allocated as b, allocatedValues as c, arrayDiff as d, attend as e, cache as f, cached as g, callOnGC as h, chainPromise as i, debounce as j, deepWatch as k, deprecated as l, descriptor as m, destructor as n, forwardArray as o, getAt as p, isCached as q, lift as r, memoize as s, morph as t, organize as u, organized as v, profileInfo as w, resource as x, setAt as y, throttle as z };
-//# sourceMappingURL=index-XsYTUhHx.esm.js.map
+//# sourceMappingURL=index-CAWVZL7P.esm.js.map