mutts 1.0.0 → 1.0.1

package/dist/reactive.d.ts

@@ -1,9 +1,9 @@
-import { LegacyClassDecorator, ModernClassDecorator, LegacyPropertyDecorator, ModernGetterDecorator, ModernAccessorDecorator, GenericClassDecorator } from './decorator.js';
+import { LegacyPropertyDecorator, ModernMethodDecorator, LegacyClassDecorator, ModernClassDecorator, ModernGetterDecorator, ModernAccessorDecorator, GenericClassDecorator } from './decorator.js';
 
 type DependencyFunction = <T>(cb: () => T) => T;
 type ScopedCallback = () => void;
 type PropEvolution = {
-    type: 'set' | 'del' | 'add';
+    type: 'set' | 'del' | 'add' | 'invalidate';
     prop: any;
 };
 type BunchEvolution = {
@@ -60,6 +60,7 @@ declare const options: {
     warn: (...args: any[]) => void;
 };
 declare function getState(obj: any): State;
+declare const atomic: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & (<Args extends any[], Return>(original: (...args: Args) => Return) => (...args: Args) => Return);
 declare class ReactiveBase {
     constructor();
 }
@@ -110,5 +111,5 @@ declare function unreactiveApplication<T extends object>(...args: (keyof T)[]):
 declare function unreactiveApplication<T extends object>(obj: T): T;
 declare const unreactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof unreactiveApplication;
 
-export { ReactiveBase, ReactiveError, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, options as reactiveOptions, unreactive, untracked, unwrap, watch };
+export { ReactiveBase, ReactiveError, atomic, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, options as reactiveOptions, unreactive, untracked, unwrap, watch };
 export type { ScopedCallback };

package/dist/reactive.esm.js

@@ -1,4 +1,4 @@
-import { d as decorator, r as renamed } from './chunks/decorator-CPbZNnsX.esm.js';
+import { d as decorator, r as renamed } from './chunks/decorator-AbRkXM5O.esm.js';
 import { Indexable } from './indexable.esm.js';
 
 // biome-ignore-all lint/suspicious/noConfusingVoidType: Type 'void' is not assignable to type 'ScopedCallback | undefined'.
@@ -19,6 +19,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
  */
@@ -140,7 +141,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) {
@@ -180,7 +181,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);
@@ -212,29 +212,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({
+    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();
@@ -309,7 +333,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);
     }
@@ -338,9 +362,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) {
@@ -367,13 +390,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;
     },
@@ -517,25 +539,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;
@@ -556,7 +560,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) {
@@ -786,28 +789,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);
 }
 /**
@@ -1197,7 +1202,8 @@ class ReactiveArray extends 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);
@@ -1209,7 +1215,6 @@ class ReactiveArray extends Indexable(ReactiveBaseArray, {
 }
 
 const native$1 = Symbol('native');
-// TODO: [prototypeForwarding]
 class ReactiveWeakMap {
     constructor(original) {
         Object.defineProperties(this, {
@@ -1332,7 +1337,6 @@ class ReactiveMap {
 }
 
 const native = Symbol('native');
-// TODO: [prototypeForwarding]
 class ReactiveWeakSet {
     constructor(original) {
         Object.defineProperties(this, {
@@ -1451,5 +1455,5 @@ registerNativeReactivity(WeakSet, ReactiveWeakSet);
 registerNativeReactivity(Set, ReactiveSet);
 registerNativeReactivity(Array, ReactiveArray);
 
-export { ReactiveBase, ReactiveError, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, options as reactiveOptions, unreactive, untracked, unwrap, watch };
+export { ReactiveBase, ReactiveError, atomic, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, options as reactiveOptions, unreactive, untracked, unwrap, watch };
 //# sourceMappingURL=reactive.esm.js.map