mutts 1.0.13 → 1.0.14

package/dist/chunks/{index-CAdnMJev.cjs → index-BnTNC9eC.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var proxy = require('./proxy-DBHj3kGK.cjs');
+var proxy = require('./proxy-HA_QQnd5.cjs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // Integrated with `using` statement via Symbol.dispose
@@ -896,22 +896,26 @@ const lift = proxy.captioned(function lift(cb) {
  */
 function morphArray(source, fn, options) {
     if (typeof source !== 'function' && !proxy.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 = proxy.tag(`morph:${fn.name || 'anonymous'}`, []);
     let input = [];
+    function currentCleanupReason() {
+        const activeEffect = proxy.getActiveEffect();
+        if (!activeEffect)
+            return undefined;
+        const node = proxy.getEffectNode(activeEffect);
+        return node.currentReason;
+    }
+    function stopEntry(entry) {
+        entry.stop(proxy.chainExternalReason({ type: 'stopped', chain: currentCleanupReason() }));
+    }
     function stopItem(key) {
         const entry = itemEffects.get(key);
         if (entry) {
-            const activeEffect = proxy.getActiveEffect();
-            let chain;
-            if (activeEffect) {
-                const node = proxy.getEffectNode(activeEffect);
-                chain = node.currentReason;
-            }
-            entry.stop(proxy.chainExternalReason({ type: 'stopped', chain }));
+            stopEntry(entry);
             itemEffects.delete(key);
         }
     }
@@ -919,15 +923,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 = proxy.reactive({ index: key });
             const stop = track(() => proxy.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];
                     proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
                     const activeEffect = proxy.getActiveEffect();
                     let chain;
@@ -937,12 +940,16 @@ function morphArray(source, fn, options) {
                     }
                     stop?.({
                         type: 'invalidate',
-                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        cause: proxy.chainExternalReason(!access.reaction || access.reaction === true
+                            ? { type: 'stopped', chain }
+                            : access.reaction),
                         chain: proxy.chainExternalReason(chain),
                     });
-                };
+                }
+                else
+                    cache[position.index] = fn(input, position, access);
             }));
-            itemEffects.set(key, { stop, index: indexRef });
+            itemEffects.set(key, { stop, position });
         }
     }
     const proxy$1 = proxy.reactive(cache, {
@@ -963,35 +970,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([proxy.keysOf]);
             if (input.length !== newInput.length)
@@ -1425,6 +1456,9 @@ function memoizeFunction(fn, opts) {
         for (const arg of args) {
             node = getBranch(node, arg);
         }
+        if (proxy.inertDepth > 0) {
+            return fn.apply(this, args);
+        }
         proxy.dependant(node, 'memoize');
         if ('result' in node) {
             if (proxy.options.onMemoizationDiscrepancy) {
@@ -2063,14 +2097,28 @@ let ReactiveArrayWrapper = (() => {
                 }, thisArg);
             }
             includes(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.includes(proxy.unwrap(searchElement), fromIndex)
-                    : super.includes(proxy.unwrap(searchElement));
+                const target = proxy.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 = proxy.unwrap(this[i]);
+                    if (value === target)
+                        return true;
+                }
+                return false;
             }
             indexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.indexOf(proxy.unwrap(searchElement), fromIndex)
-                    : super.indexOf(proxy.unwrap(searchElement));
+                const target = proxy.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 (proxy.unwrap(this[i]) === target)
+                        return i;
+                return -1;
             }
             join(separator) {
                 return super.join(separator);
@@ -2080,9 +2128,17 @@ let ReactiveArrayWrapper = (() => {
                 return super.keys();
             }
             lastIndexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.lastIndexOf(proxy.unwrap(searchElement), fromIndex)
-                    : super.lastIndexOf(proxy.unwrap(searchElement));
+                const target = proxy.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 (proxy.unwrap(this[i]) === target)
+                        return i;
+                return -1;
             }
             map(callbackfn, thisArg) {
                 return proxy.reactive(super.map((v, i, a) => proxy.unwrap(callbackfn.call(thisArg, proxy.reactive(v), i, a)), thisArg));
@@ -2122,13 +2178,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 proxy.reactive(super.splice(start, deleteCount, ...items.map(proxy.unwrap)));
-                if (arguments.length === 2)
-                    return proxy.reactive(super.splice(start, deleteCount));
-                if (arguments.length === 1)
-                    return proxy.reactive(super.splice(start));
-                return proxy.reactive([]);
+                    result = super.splice(start, deleteCount, ...items.map(proxy.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) {
+                    proxy.touched(this, { type: 'set', prop: 'length' }, ['length']);
+                }
+                return proxy.reactive(result);
             }
             unshift(...items) {
                 return super.unshift(...items.map(proxy.unwrap));
@@ -2183,6 +2251,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)
@@ -2231,10 +2305,8 @@ class ReactiveMap extends Map {
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
             // Clear triggers all effects since all keys are affected
-            proxy.batch(() => {
-                proxy.touched1(this, evolution, 'size');
-                proxy.touched(proxy.contentRef(this), evolution);
-            });
+            proxy.touched1(this, evolution, 'size');
+            proxy.touched(proxy.contentRef(this), evolution);
         }
     }
     entries() {
@@ -2272,10 +2344,8 @@ class ReactiveMap extends Map {
         const result = super.delete(key);
         if (hadKey) {
             const evolution = { type: 'del', prop: key };
-            proxy.batch(() => {
-                proxy.touched1(proxy.contentRef(this), evolution, key);
-                proxy.touched1(this, evolution, 'size');
-            });
+            proxy.touched1(proxy.contentRef(this), evolution, key);
+            proxy.touched1(this, evolution, 'size');
         }
         return result;
     }
@@ -2293,17 +2363,21 @@ class ReactiveMap extends Map {
         const reactiveValue = proxy.reactive(value);
         super.set(key, reactiveValue);
         if (!hadKey || oldValue !== reactiveValue) {
-            proxy.batch(() => {
-                proxy.notifyPropertyChange(proxy.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 };
-                proxy.touched1(this, evolution, 'size');
-            });
+            proxy.notifyPropertyChange(proxy.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 };
+            proxy.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)
@@ -2348,10 +2422,8 @@ class ReactiveSet extends Set {
         if (!had) {
             const evolution = { type: 'add', prop: reactiveValue };
             // touch for value-specific and aggregate dependencies
-            proxy.batch(() => {
-                proxy.touched1(proxy.contentRef(this), evolution, reactiveValue);
-                proxy.touched1(this, evolution, 'size');
-            });
+            proxy.touched1(proxy.contentRef(this), evolution, reactiveValue);
+            proxy.touched1(this, evolution, 'size');
         }
         return this;
     }
@@ -2360,10 +2432,8 @@ class ReactiveSet extends Set {
         super.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
-            proxy.batch(() => {
-                proxy.touched1(this, evolution, 'size');
-                proxy.touched(proxy.contentRef(this), evolution);
-            });
+            proxy.touched1(this, evolution, 'size');
+            proxy.touched(proxy.contentRef(this), evolution);
         }
     }
     delete(value) {
@@ -2371,10 +2441,8 @@ class ReactiveSet extends Set {
         const res = super.delete(value);
         if (had) {
             const evolution = { type: 'del', prop: value };
-            proxy.batch(() => {
-                proxy.touched1(proxy.contentRef(this), evolution, value);
-                proxy.touched1(this, evolution, 'size');
-            });
+            proxy.touched1(proxy.contentRef(this), evolution, value);
+            proxy.touched1(this, evolution, 'size');
         }
         return res;
     }
@@ -2662,7 +2730,7 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.13";
+var version$1 = "1.0.14";
 var pkg = {
 	version: version$1};
 
@@ -2681,8 +2749,8 @@ if (globalScope) {
     try {
         if (runtimeGlobals.__filename)
             source = runtimeGlobals.__filename;
-        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-CAdnMJev.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-CAdnMJev.cjs', document.baseURI).href))) {
-            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-CAdnMJev.cjs', document.baseURI).href));
+        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-BnTNC9eC.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-BnTNC9eC.cjs', document.baseURI).href))) {
+            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-BnTNC9eC.cjs', document.baseURI).href));
         }
     }
     catch (_e) { }
@@ -2732,4 +2800,4 @@ exports.throttle = throttle;
 exports.unreactive = unreactive;
 exports.watch = watch;
 exports.when = when;
-//# sourceMappingURL=index-CAdnMJev.cjs.map
+//# sourceMappingURL=index-BnTNC9eC.cjs.map