mutts 1.0.7 → 1.0.8

package/dist/chunks/{index-CNR6QRUl.esm.js → index-DhaOVusv.esm.js}

@@ -1,8 +1,22 @@
 const asyncHooks = {
     addHook(_hook) {
         throw 'One must import the library from the server or the client side';
+    },
+    /**
+     * [Hack] Sanitize a promise (or value) to prevent context leaks.
+     * Default: Identity function.
+     * Browser: Uses Macrotask wrapping to break microtask chains.
+     */
+    sanitizePromise(p) {
+        return p;
     }
 };
+/**
+ * Register a hook that will be called whenever an asynchronous operation is initiated.
+ * The hook should return a restorer function which will be called just before the async callback runs.
+ * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
+ */
+const asyncHook = (hook) => asyncHooks.addHook(hook);
 
 /**
  * Combines multiple arrays into an array of tuples, stopping at the shortest array length
@@ -264,7 +278,7 @@ function contentRef(container) {
         })));
     return contentRefs.get(container);
 }
-function tag(obj, name) {
+function tag(name, obj) {
     Object.defineProperties(obj, {
         [Symbol.toStringTag]: {
             value: name,
@@ -2057,6 +2071,9 @@ function addToMutationHistory(source, target, obj, prop, evolution) {
 }
 
 var _ZoneAggregator_zones;
+function isu(z) {
+    return z;
+}
 class AZone {
     enter(value) {
         const prev = this.active;
@@ -2068,12 +2085,16 @@ class AZone {
     }
     with(value, fn) {
         const entered = this.enter(value);
+        let res;
         try {
-            return fn();
+            res = fn();
         }
         finally {
             this.leave(entered);
         }
+        // [HACK]: Sanitization
+        // See BROWSER_ASYNC_POLYFILL.md
+        return asyncHooks.sanitizePromise(res);
     }
     root(fn) {
         let prev = this.enter();
@@ -2116,12 +2137,12 @@ class ZoneHistory extends AZone {
                     throw new Error('ZoneHistory: re-entering historical zone');
                 if (value !== undefined)
                     self.history.add(value);
-                return { added: value, entered: controlled.enter(value) };
+                return { added: value, entered: isu(controlled).enter(value) };
             },
             leave(entered) {
                 if (entered.added !== undefined)
                     self.history.delete(entered.added);
-                return controlled.leave(entered.entered);
+                return isu(controlled).leave(entered.entered);
             }
         }));
     }
@@ -2155,13 +2176,13 @@ class ZoneAggregator extends AZone {
         const entered = new Map();
         for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f")) {
             const v = value?.get(z);
-            entered.set(z, z.enter(v));
+            entered.set(z, isu(z).enter(v));
         }
         return entered;
     }
     leave(entered) {
         for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f"))
-            z.leave(entered.get(z));
+            isu(z).leave(entered.get(z));
     }
     add(z) {
         __classPrivateFieldGet(this, _ZoneAggregator_zones, "f").add(z);
@@ -2174,7 +2195,7 @@ class ZoneAggregator extends AZone {
     }
 }
 _ZoneAggregator_zones = new WeakMap();
-const asyncZone = tag(new ZoneAggregator(), 'async');
+const asyncZone = tag('async', new ZoneAggregator());
 asyncHooks.addHook(() => {
     const zone = asyncZone.active;
     return () => {
@@ -2184,10 +2205,10 @@ asyncHooks.addHook(() => {
     };
 });
 
-const effectHistory = tag(new ZoneHistory(), 'effectHistory');
-tag(effectHistory.present, 'effectHistory.present');
+const effectHistory = tag('effectHistory', new ZoneHistory());
+tag('effectHistory.present', effectHistory.present);
 asyncZone.add(effectHistory);
-const effectAggregator = tag(new ZoneAggregator(effectHistory.present), 'effectAggregator');
+const effectAggregator = tag('effectAggregator', new ZoneAggregator(effectHistory.present));
 function isRunning(effect) {
     const root = getRoot(effect);
     return effectHistory.some((e) => getRoot(e) === root);
@@ -5450,6 +5471,17 @@ function scan(source, callback, initialValue) {
         indexEffects.clear();
     });
 }
+function resolve(cb) {
+    const result = reactive([]);
+    return cleanedBy(result, effect(() => {
+        const source = cb();
+        if (result.length !== source.length)
+            result.length = source.length;
+        for (let i = 0; i < source.length; i++)
+            if (result[i] !== source[i])
+                result[i] = source[i];
+    }));
+}
 
 function* index(i, { length = true } = {}) {
     if (length)
@@ -5522,6 +5554,8 @@ class ReactiveArray extends Array {
     at(index) {
         const actualIndex = index < 0 ? this.length + index : index;
         dependant(this, actualIndex);
+        if (index < 0)
+            dependant(this, 'length');
         if (actualIndex < 0 || actualIndex >= this.length)
             return undefined;
         return reactive(this[actualIndex]);
@@ -5576,36 +5610,61 @@ class ReactiveArray extends Array {
         };
     }
     indexOf(searchElement, fromIndex) {
-        dependant(this);
+        const length = this.length;
+        let i = fromIndex === undefined ? 0 : fromIndex;
+        if (i < 0)
+            i = Math.max(length + i, 0);
         const unwrappedSearch = unwrap(searchElement);
-        // Check both wrapped and unwrapped versions since array may contain either
-        const index = this.indexOf(unwrappedSearch, fromIndex);
-        if (index !== -1)
-            return index;
-        // If not found with unwrapped, try with wrapped (in case array contains wrapped version)
-        return this.indexOf(searchElement, fromIndex);
+        for (; i < length; i++) {
+            dependant(this, i);
+            const item = this[i];
+            if (item === searchElement || item === unwrappedSearch || unwrap(item) === unwrappedSearch) {
+                return i;
+            }
+        }
+        dependant(this, 'length');
+        return -1;
     }
     lastIndexOf(searchElement, fromIndex) {
-        dependant(this);
+        const length = this.length;
+        let i = fromIndex === undefined ? length - 1 : fromIndex;
+        if (i >= length)
+            i = length - 1;
+        if (i < 0)
+            i = Math.max(length + i, -1); // -1 ensures loop condition i >= 0 works correctly
         const unwrappedSearch = unwrap(searchElement);
-        // Check both wrapped and unwrapped versions since array may contain either
-        const index = this.lastIndexOf(unwrappedSearch, fromIndex);
-        if (index !== -1)
-            return index;
-        // If not found with unwrapped, try with wrapped (in case array contains wrapped version)
-        return this.lastIndexOf(searchElement, fromIndex);
+        for (; i >= 0; i--) {
+            dependant(this, i);
+            const item = this[i];
+            if (item === searchElement || item === unwrappedSearch || unwrap(item) === unwrappedSearch) {
+                return i;
+            }
+        }
+        // If we scanned the whole relevant part and didn't find it, we depend on length 
+        // (because adding elements might shift indices or add the element)
+        // Actually for lastIndexOf, if we start from end, length dependency is implicit in the start index calculation?
+        // But if we return -1, it means we didn't find it.
+        // If we push an element, should lastIndexOf update?
+        // Yes, if the new element is the one we are looking for.
+        dependant(this, 'length');
+        return -1;
     }
     includes(searchElement, fromIndex) {
-        dependant(this);
-        const unwrappedSearch = unwrap(searchElement);
-        // Check both wrapped and unwrapped versions since array may contain either
-        return this.includes(unwrappedSearch, fromIndex) || this.includes(searchElement, fromIndex);
+        return this.indexOf(searchElement, fromIndex) !== -1;
     }
     find(predicateOrElement, thisArg) {
-        dependant(this);
         if (typeof predicateOrElement === 'function') {
             const predicate = predicateOrElement;
-            return reactive(this.find((value, index, array) => predicate.call(thisArg, reactive(value), index, array), thisArg));
+            const length = this.length;
+            for (let i = 0; i < length; i++) {
+                dependant(this, i);
+                const val = reactive(this[i]);
+                if (predicate.call(thisArg, val, i, this)) {
+                    return val;
+                }
+            }
+            dependant(this, 'length');
+            return undefined;
         }
         const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
         const index = this.indexOf(predicateOrElement, fromIndex);
@@ -5614,10 +5673,18 @@ class ReactiveArray extends Array {
         return reactive(this[index]);
     }
     findIndex(predicateOrElement, thisArg) {
-        dependant(this);
         if (typeof predicateOrElement === 'function') {
             const predicate = predicateOrElement;
-            return this.findIndex((value, index, array) => predicate.call(thisArg, reactive(value), index, array), thisArg);
+            const length = this.length;
+            for (let i = 0; i < length; i++) {
+                dependant(this, i);
+                const val = reactive(this[i]);
+                if (predicate.call(thisArg, val, i, this)) {
+                    return i;
+                }
+            }
+            dependant(this, 'length');
+            return -1;
         }
         const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
         return this.indexOf(predicateOrElement, fromIndex);
@@ -5676,12 +5743,26 @@ class ReactiveArray extends Array {
         });
     }
     every(callbackfn, thisArg) {
-        dependant(this);
-        return this.every((value, index, array) => callbackfn.call(thisArg, reactive(value), index, array), thisArg);
+        const length = this.length;
+        for (let i = 0; i < length; i++) {
+            dependant(this, i);
+            if (!callbackfn.call(thisArg, reactive(this[i]), i, this)) {
+                return false;
+            }
+        }
+        dependant(this, 'length');
+        return true;
     }
     some(callbackfn, thisArg) {
-        dependant(this);
-        return this.some((value, index, array) => callbackfn.call(thisArg, reactive(value), index, array), thisArg);
+        const length = this.length;
+        for (let i = 0; i < length; i++) {
+            dependant(this, i);
+            if (callbackfn.call(thisArg, reactive(this[i]), i, this)) {
+                return true;
+            }
+        }
+        dependant(this, 'length');
+        return false;
     }
     // Side-effectful
     push(...items) {
@@ -5723,19 +5804,29 @@ class ReactiveArray extends Array {
     }
     splice(start, deleteCount, ...items) {
         const oldLength = this.length;
-        if (deleteCount === undefined)
-            deleteCount = oldLength - start;
+        // Normalize start index
+        let actualStart = start;
+        if (actualStart < 0)
+            actualStart = Math.max(oldLength + actualStart, 0);
+        else
+            actualStart = Math.min(actualStart, oldLength);
+        // Normalize deleteCount
+        let actualDeleteCount = deleteCount;
+        if (actualDeleteCount === undefined) {
+            actualDeleteCount = oldLength - actualStart;
+        }
+        else {
+            actualDeleteCount = Math.max(0, Math.min(actualDeleteCount, oldLength - actualStart));
+        }
         try {
             if (deleteCount === undefined)
                 return reactive(this.splice(start));
             return reactive(this.splice(start, deleteCount, ...items));
         }
         finally {
-            touched(this, { type: 'bunch', method: 'splice' }, 
-            // TODO: edge cases
-            deleteCount === items.length
-                ? range(start, start + deleteCount)
-                : range(start, oldLength + Math.max(items.length - deleteCount, 0), {
+            touched(this, { type: 'bunch', method: 'splice' }, actualDeleteCount === items.length
+                ? range(actualStart, actualStart + actualDeleteCount - 1)
+                : range(actualStart, oldLength + Math.max(items.length - actualDeleteCount, 0), {
                     length: true,
                 }));
         }
@@ -5758,6 +5849,17 @@ class ReactiveArray extends Array {
         }
     }
     fill(value, start, end) {
+        const len = this.length;
+        let k = start === undefined ? 0 : start;
+        if (k < 0)
+            k = Math.max(len + k, 0);
+        else
+            k = Math.min(k, len);
+        let final = end === undefined ? len : end;
+        if (final < 0)
+            final = Math.max(len + final, 0);
+        else
+            final = Math.min(final, len);
         try {
             if (start === undefined)
                 return this.fill(value);
@@ -5766,7 +5868,9 @@ class ReactiveArray extends Array {
             return this.fill(value, start, end);
         }
         finally {
-            touched(this, { type: 'bunch', method: 'fill' }, range(0, this.length - 1));
+            if (final > k) {
+                touched(this, { type: 'bunch', method: 'fill' }, range(k, final - 1));
+            }
         }
     }
     copyWithin(target, start, end) {
@@ -5776,11 +5880,27 @@ class ReactiveArray extends Array {
             return this.copyWithin(target, start, end);
         }
         finally {
-            touched(this, { type: 'bunch', method: 'copyWithin' }, 
-            // TODO: calculate the range properly
-            range(0, this.length - 1));
+            const len = this.length;
+            let to = target;
+            if (to < 0)
+                to = Math.max(len + to, 0);
+            else if (to >= len)
+                to = len;
+            let from = start;
+            if (from < 0)
+                from = Math.max(len + from, 0);
+            else if (from >= len)
+                from = len;
+            let final = end === undefined ? len : end;
+            if (final < 0)
+                final = Math.max(len + final, 0);
+            else if (final >= len)
+                final = len;
+            const count = Math.min(final - from, len - to);
+            if (count > 0) {
+                touched(this, { type: 'bunch', method: 'copyWithin' }, range(to, to + count - 1));
+            }
         }
-        // Touch all affected indices with a single allProps call
     }
 }
 
@@ -5876,7 +5996,7 @@ class ReactiveMap extends Map {
                 return this;
             },
             [Symbol.dispose]() { },
-        };
+        }; // TODO: real iterator? (If easy)
     }
     // Implement Map methods with reactivity
     delete(key) {
@@ -6021,7 +6141,7 @@ class ReactiveSet extends Set {
                 return this;
             },
             [Symbol.dispose]() { },
-        };
+        }; //TODO? (something easy)
     }
 }
 
@@ -6238,7 +6358,7 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.7";
+var version$1 = "1.0.8";
 var pkg = {
 	version: version$1};
 
@@ -6287,5 +6407,5 @@ if (globalScope) {
     globalScope[GLOBAL_MUTTS_KEY] = currentSourceInfo;
 }
 
-export { isNonReactive as $, AZone as A, debounce as B, decorator as C, DecoratorError as D, Eventful as E, FoolProof as F, deepCompare as G, deepWatch as H, Indexable as I, defer as J, deprecated as K, derived as L, describe as M, destructor as N, effect as O, enableDevTools as P, forwardArray as Q, ReactiveBase as R, getActivationLog as S, getActiveProjection as T, getAt as U, getState as V, immutables as W, isCached as X, isConstructor as Y, Zone as Z, isDevtoolsEnabled as _, asyncHooks as a, isOwnAccessor as a0, isReactive as a1, legacyDecorator as a2, memoize as a3, mixin as a4, modernDecorator as a5, named as a6, organize as a7, organized as a8, profileInfo as a9, project as aa, reactive as ab, options as ac, register as ad, registerEffectForDebug as ae, registerNativeReactivity as af, registerObjectForDebug as ag, renamed as ah, root as ai, scan as aj, setAt as ak, setEffectName as al, setObjectName as am, tag as an, throttle as ao, touched as ap, touched1 as aq, trackEffect as ar, unreactive as as, untracked as at, unwrap as au, watch as av, zip as aw, ArrayReadForward as b, Destroyable as c, DestructionError as d, IterableWeakMap as e, IterableWeakSet as f, ReactiveError as g, ReactiveErrorCode as h, Register as i, ZoneAggregator as j, ZoneHistory as k, addBatchCleanup as l, allocated as m, allocatedValues as n, arrayEquals as o, asyncZone as p, atomic as q, biDi as r, buildReactivityGraph as s, cache as t, cached as u, callOnGC as v, chainPromise as w, cleanedBy as x, cleanup as y, contentRef as z };
-//# sourceMappingURL=index-CNR6QRUl.esm.js.map
+export { isCached as $, AZone as A, contentRef as B, debounce as C, DecoratorError as D, Eventful as E, FoolProof as F, decorator as G, deepCompare as H, Indexable as I, deepWatch as J, defer as K, deprecated as L, derived as M, describe as N, destructor as O, effect as P, effectAggregator as Q, ReactiveBase as R, enableDevTools as S, forwardArray as T, getActivationLog as U, getActiveEffect as V, getActiveProjection as W, getAt as X, getState as Y, Zone as Z, immutables as _, asyncHooks as a, isConstructor as a0, isDevtoolsEnabled as a1, isNonReactive as a2, isOwnAccessor as a3, isReactive as a4, legacyDecorator as a5, memoize as a6, mixin as a7, modernDecorator as a8, named as a9, zip as aA, organize as aa, organized as ab, profileInfo as ac, project as ad, reactive as ae, options as af, register as ag, registerEffectForDebug as ah, registerNativeReactivity as ai, registerObjectForDebug as aj, renamed as ak, resolve as al, root as am, scan as an, setAt as ao, setEffectName as ap, setObjectName as aq, tag as ar, throttle as as, touched as at, touched1 as au, trackEffect as av, unreactive as aw, untracked as ax, unwrap as ay, watch as az, ArrayReadForward as b, Destroyable as c, DestructionError as d, IterableWeakMap as e, IterableWeakSet as f, ReactiveError as g, ReactiveErrorCode as h, Register as i, ZoneAggregator as j, ZoneHistory as k, addBatchCleanup as l, allocated as m, allocatedValues as n, arrayEquals as o, asyncHook as p, asyncZone as q, atomic as r, biDi as s, buildReactivityGraph as t, cache as u, cached as v, callOnGC as w, chainPromise as x, cleanedBy as y, cleanup as z };
+//# sourceMappingURL=index-DhaOVusv.esm.js.map