mutts 1.0.0 → 1.0.1

package/dist/reactive.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var decorator = require('./chunks/decorator-BXsign4Z.js');
+var decorator = require('./chunks/decorator-8qjFb7dw.js');
 var indexable = require('./indexable.js');
 
 // biome-ignore-all lint/suspicious/noConfusingVoidType: Type 'void' is not assignable to type 'ScopedCallback | undefined'.
@@ -21,6 +21,7 @@ const deepWatchers = new WeakMap();
 const effectToDeepWatchedObjects = new WeakMap();
 // Track objects that should never be reactive and cannot be modified
 const nonReactiveObjects = new WeakSet();
+const absent = Symbol('absent');
 /**
  * Converts an iterator to a generator that yields reactive values
  */
@@ -142,7 +143,7 @@ function raiseDeps(objectWatchers, ...keyChains) {
             const deps = objectWatchers.get(key);
             if (deps)
                 for (const effect of Array.from(deps))
-                    hasEffect(effect);
+                    atomicEffect(effect);
         }
 }
 function touched1(obj, evolution, prop) {
@@ -182,7 +183,6 @@ function getState(obj) {
     return state;
 }
 function dependant(obj, prop = allProps) {
-    // TODO: avoid depending on property get?
     obj = unwrap(obj);
     if (activeEffect && (typeof prop !== 'symbol' || prop === allProps)) {
         let objectWatchers = watchers.get(obj);
@@ -214,29 +214,53 @@ let parentEffect;
 let batchedEffects;
 // Track which sub-effects have been executed to prevent infinite loops
 // These are all the effects triggered under `activeEffect` and all their sub-effects
-function hasEffect(effect) {
+function atomicEffect(effect, immediate) {
     const root = getRoot(effect);
     options?.chain(getRoot(effect), getRoot(activeEffect));
-    if (batchedEffects)
+    if (batchedEffects) {
         batchedEffects.set(root, effect);
+        if (immediate)
+            try {
+                return effect();
+            }
+            finally {
+                batchedEffects.delete(root);
+            }
+    }
     else {
         const runEffects = [];
         batchedEffects = new Map([[root, effect]]);
+        const firstReturn = {};
         try {
             while (batchedEffects.size) {
                 if (runEffects.length > options.maxEffectChain)
                     throw new ReactiveError('[reactive] Max effect chain reached');
                 const [root, effect] = batchedEffects.entries().next().value;
                 runEffects.push(root);
-                effect();
+                const rv = effect();
+                if (!('value' in firstReturn))
+                    firstReturn.value = rv;
                 batchedEffects.delete(root);
             }
+            return firstReturn.value;
         }
         finally {
             batchedEffects = undefined;
         }
     }
 }
+const atomic = decorator.decorator({
+    method(original) {
+        return function (...args) {
+            return atomicEffect(markWithRoot(() => original.apply(this, args), original), 'immediate');
+        };
+    },
+    default(original) {
+        return function (...args) {
+            return atomicEffect(markWithRoot(() => original.apply(this, args), original), 'immediate');
+        };
+    },
+});
 function withEffect(effect, fn, keepParent) {
     if (getRoot(effect) === getRoot(activeEffect))
         return fn();
@@ -311,7 +335,7 @@ function bubbleUpChange(changedObject, evolution) {
         const parentDeepWatchers = deepWatchers.get(parent);
         if (parentDeepWatchers)
             for (const watcher of parentDeepWatchers)
-                hasEffect(watcher);
+                atomicEffect(watcher);
         // Continue bubbling up
         bubbleUpChange(parent);
     }
@@ -340,9 +364,8 @@ const reactiveHandlers = {
         // Check if this property is marked as unreactive
         if (obj[unreactiveProperties]?.has(prop) || typeof prop === 'symbol')
             return Reflect.get(obj, prop, receiver);
-        const absent = !(prop in obj);
         // Depend if...
-        if (!options.instanceMembers || Object.hasOwn(receiver, prop) || absent)
+        if (!options.instanceMembers || Object.hasOwn(receiver, prop) || !Reflect.has(receiver, prop))
             dependant(obj, prop);
         const value = Reflect.get(obj, prop, receiver);
         if (typeof value === 'object' && value !== null) {
@@ -369,13 +392,12 @@ const reactiveHandlers = {
             obj[prop] = newValue;
             return true;
         }
-        const oldVal = obj[prop];
-        const oldPresent = prop in obj;
+        const oldVal = Reflect.has(receiver, prop) ? Reflect.get(obj, prop, receiver) : absent;
         track1(obj, prop, oldVal, newValue);
         if (oldVal !== newValue) {
             Reflect.set(obj, prop, newValue, receiver);
             // try to find a "generic" way to express that
-            touched1(obj, { type: oldPresent ? 'set' : 'add', prop }, prop);
+            touched1(obj, { type: oldVal !== absent ? 'set' : 'add', prop }, prop);
         }
         return true;
     },
@@ -519,25 +541,7 @@ function effect(fn, ...args) {
     }
     // Mark the runEffect callback with the original function as its root
     markWithRoot(runEffect, fn);
-    // Run the effect immediately
-    if (!batchedEffects) {
-        hasEffect(runEffect);
-    }
-    else {
-        const oldBatchedEffects = batchedEffects;
-        try {
-            // Simulate a hasEffect who batches, but do not execute the batch, give it back to the parent batch,
-            // Only the immediate effect has to be executed, the sub-effects will be executed by the parent batch
-            batchedEffects = new Map([[fn, runEffect]]);
-            runEffect();
-            batchedEffects.delete(fn);
-            for (const [root, effect] of batchedEffects)
-                oldBatchedEffects.set(root, effect);
-        }
-        finally {
-            batchedEffects = oldBatchedEffects;
-        }
-    }
+    atomicEffect(runEffect, 'immediate');
     const mainCleanup = () => {
         if (effectStopped)
             return;
@@ -558,7 +562,6 @@ function effect(fn, ...args) {
         fr.register(callIfCollected, mainCleanup, callIfCollected);
         return callIfCollected;
     }
-    // TODO: parentEffect = last non-undefined activeEffect
     // Register this effect to be cleaned up with the parent effect
     let children = effectChildren.get(parentEffect);
     if (!children) {
@@ -788,28 +791,30 @@ function computedFunction(getter) {
     dependant(computedCache, key);
     if (computedCache.has(key))
         return computedCache.get(key);
-    withEffect(undefined, () => {
-        const stop = effect(markWithRoot((dep) => {
-            const oldCI = computedInvalidations;
-            if (computedCache.has(key)) {
-                // This should *not* be called in the cleanup chain, as its effects would be lost and cleaned-up
-                for (const cb of invalidations)
-                    cb();
-                invalidations = [];
-                computedCache.delete(key);
-                touched1(computedCache, { type: 'set', prop: key }, key);
-                stop();
+    let stopped = false;
+    const stop = effect(markWithRoot((dep) => {
+        if (stopped)
+            return;
+        const oldCI = computedInvalidations;
+        if (computedCache.has(key)) {
+            // This should *not* be called in the cleanup chain, as its effects would be lost and cleaned-up
+            for (const cb of invalidations)
+                cb();
+            invalidations = [];
+            computedCache.delete(key);
+            touched1(computedCache, { type: 'invalidate', prop: key }, key);
+            stop();
+            stopped = true;
+        }
+        else
+            try {
+                computedInvalidations = invalidations;
+                computedCache.set(key, getter(dep));
             }
-            else
-                try {
-                    computedInvalidations = invalidations;
-                    computedCache.set(key, getter(dep));
-                }
-                finally {
-                    computedInvalidations = oldCI;
-                }
-        }, getter));
-    });
+            finally {
+                computedInvalidations = oldCI;
+            }
+    }, getter));
     return computedCache.get(key);
 }
 /**
@@ -1199,7 +1204,8 @@ class ReactiveArray extends indexable.Indexable(ReactiveBaseArray, {
         dependant(this);
         this[native$2].forEach(callbackfn, thisArg);
     }
-    // TODO: re-implement for fun dependencies? (eg - every only check the first ones until it find some)
+    // TODO: re-implement for fun dependencies? (eg - every only check the first ones until it find some),
+    // no need to make it dependant on indexes after the found one
     every(callbackfn, thisArg) {
         dependant(this);
         return this[native$2].every(callbackfn, thisArg);
@@ -1211,7 +1217,6 @@ class ReactiveArray extends indexable.Indexable(ReactiveBaseArray, {
 }
 
 const native$1 = Symbol('native');
-// TODO: [prototypeForwarding]
 class ReactiveWeakMap {
     constructor(original) {
         Object.defineProperties(this, {
@@ -1334,7 +1339,6 @@ class ReactiveMap {
 }
 
 const native = Symbol('native');
-// TODO: [prototypeForwarding]
 class ReactiveWeakSet {
     constructor(original) {
         Object.defineProperties(this, {
@@ -1455,6 +1459,7 @@ registerNativeReactivity(Array, ReactiveArray);
 
 exports.ReactiveBase = ReactiveBase;
 exports.ReactiveError = ReactiveError;
+exports.atomic = atomic;
 exports.computed = computed;
 exports.effect = effect;
 exports.getState = getState;