mobx 5.13.1 → 5.14.0

package/lib/mobx.umd.js

@@ -599,6 +599,274 @@
     };
     computed.struct = computedStructDecorator;
 
+    (function (IDerivationState) {
+        // before being run or (outside batch and not being observed)
+        // at this point derivation is not holding any data about dependency tree
+        IDerivationState[IDerivationState["NOT_TRACKING"] = -1] = "NOT_TRACKING";
+        // no shallow dependency changed since last computation
+        // won't recalculate derivation
+        // this is what makes mobx fast
+        IDerivationState[IDerivationState["UP_TO_DATE"] = 0] = "UP_TO_DATE";
+        // some deep dependency changed, but don't know if shallow dependency changed
+        // will require to check first if UP_TO_DATE or POSSIBLY_STALE
+        // currently only ComputedValue will propagate POSSIBLY_STALE
+        //
+        // having this state is second big optimization:
+        // don't have to recompute on every dependency change, but only when it's needed
+        IDerivationState[IDerivationState["POSSIBLY_STALE"] = 1] = "POSSIBLY_STALE";
+        // A shallow dependency has changed since last computation and the derivation
+        // will need to recompute when it's needed next.
+        IDerivationState[IDerivationState["STALE"] = 2] = "STALE";
+    })(exports.IDerivationState || (exports.IDerivationState = {}));
+    var TraceMode;
+    (function (TraceMode) {
+        TraceMode[TraceMode["NONE"] = 0] = "NONE";
+        TraceMode[TraceMode["LOG"] = 1] = "LOG";
+        TraceMode[TraceMode["BREAK"] = 2] = "BREAK";
+    })(TraceMode || (TraceMode = {}));
+    var CaughtException = /** @class */ (function () {
+        function CaughtException(cause) {
+            this.cause = cause;
+            // Empty
+        }
+        return CaughtException;
+    }());
+    function isCaughtException(e) {
+        return e instanceof CaughtException;
+    }
+    /**
+     * Finds out whether any dependency of the derivation has actually changed.
+     * If dependenciesState is 1 then it will recalculate dependencies,
+     * if any dependency changed it will propagate it by changing dependenciesState to 2.
+     *
+     * By iterating over the dependencies in the same order that they were reported and
+     * stopping on the first change, all the recalculations are only called for ComputedValues
+     * that will be tracked by derivation. That is because we assume that if the first x
+     * dependencies of the derivation doesn't change then the derivation should run the same way
+     * up until accessing x-th dependency.
+     */
+    function shouldCompute(derivation) {
+        switch (derivation.dependenciesState) {
+            case exports.IDerivationState.UP_TO_DATE:
+                return false;
+            case exports.IDerivationState.NOT_TRACKING:
+            case exports.IDerivationState.STALE:
+                return true;
+            case exports.IDerivationState.POSSIBLY_STALE: {
+                var prevUntracked = untrackedStart(); // no need for those computeds to be reported, they will be picked up in trackDerivedFunction.
+                var obs = derivation.observing, l = obs.length;
+                for (var i = 0; i < l; i++) {
+                    var obj = obs[i];
+                    if (isComputedValue(obj)) {
+                        if (globalState.disableErrorBoundaries) {
+                            obj.get();
+                        }
+                        else {
+                            try {
+                                obj.get();
+                            }
+                            catch (e) {
+                                // we are not interested in the value *or* exception at this moment, but if there is one, notify all
+                                untrackedEnd(prevUntracked);
+                                return true;
+                            }
+                        }
+                        // if ComputedValue `obj` actually changed it will be computed and propagated to its observers.
+                        // and `derivation` is an observer of `obj`
+                        // invariantShouldCompute(derivation)
+                        if (derivation.dependenciesState === exports.IDerivationState.STALE) {
+                            untrackedEnd(prevUntracked);
+                            return true;
+                        }
+                    }
+                }
+                changeDependenciesStateTo0(derivation);
+                untrackedEnd(prevUntracked);
+                return false;
+            }
+        }
+    }
+    // function invariantShouldCompute(derivation: IDerivation) {
+    //     const newDepState = (derivation as any).dependenciesState
+    //     if (
+    //         process.env.NODE_ENV === "production" &&
+    //         (newDepState === IDerivationState.POSSIBLY_STALE ||
+    //             newDepState === IDerivationState.NOT_TRACKING)
+    //     )
+    //         fail("Illegal dependency state")
+    // }
+    function isComputingDerivation() {
+        return globalState.trackingDerivation !== null; // filter out actions inside computations
+    }
+    function checkIfStateModificationsAreAllowed(atom) {
+        var hasObservers = atom.observers.size > 0;
+        // Should never be possible to change an observed observable from inside computed, see #798
+        if (globalState.computationDepth > 0 && hasObservers)
+            fail(process.env.NODE_ENV !== "production" &&
+                "Computed values are not allowed to cause side effects by changing observables that are already being observed. Tried to modify: " + atom.name);
+        // Should not be possible to change observed state outside strict mode, except during initialization, see #563
+        if (!globalState.allowStateChanges && (hasObservers || globalState.enforceActions === "strict"))
+            fail(process.env.NODE_ENV !== "production" &&
+                (globalState.enforceActions
+                    ? "Since strict-mode is enabled, changing observed observable values outside actions is not allowed. Please wrap the code in an `action` if this change is intended. Tried to modify: "
+                    : "Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, the render function of a React component? Tried to modify: ") +
+                    atom.name);
+    }
+    function checkIfStateReadsAreAllowed(observable) {
+        if (process.env.NODE_ENV !== "production" &&
+            !globalState.allowStateReads &&
+            globalState.observableRequiresReaction) {
+            console.warn("[mobx] Observable " + observable.name + " being read outside a reactive context");
+        }
+    }
+    /**
+     * Executes the provided function `f` and tracks which observables are being accessed.
+     * The tracking information is stored on the `derivation` object and the derivation is registered
+     * as observer of any of the accessed observables.
+     */
+    function trackDerivedFunction(derivation, f, context) {
+        var prevAllowStateReads = allowStateReadsStart(true);
+        // pre allocate array allocation + room for variation in deps
+        // array will be trimmed by bindDependencies
+        changeDependenciesStateTo0(derivation);
+        derivation.newObserving = new Array(derivation.observing.length + 100);
+        derivation.unboundDepsCount = 0;
+        derivation.runId = ++globalState.runId;
+        var prevTracking = globalState.trackingDerivation;
+        globalState.trackingDerivation = derivation;
+        var result;
+        if (globalState.disableErrorBoundaries === true) {
+            result = f.call(context);
+        }
+        else {
+            try {
+                result = f.call(context);
+            }
+            catch (e) {
+                result = new CaughtException(e);
+            }
+        }
+        globalState.trackingDerivation = prevTracking;
+        bindDependencies(derivation);
+        warnAboutDerivationWithoutDependencies(derivation);
+        allowStateReadsEnd(prevAllowStateReads);
+        return result;
+    }
+    function warnAboutDerivationWithoutDependencies(derivation) {
+        if (process.env.NODE_ENV === "production")
+            return;
+        if (derivation.observing.length !== 0)
+            return;
+        if (globalState.reactionRequiresObservable || derivation.requiresObservable) {
+            console.warn("[mobx] Derivation " + derivation.name + " is created/updated without reading any observable value");
+        }
+    }
+    /**
+     * diffs newObserving with observing.
+     * update observing to be newObserving with unique observables
+     * notify observers that become observed/unobserved
+     */
+    function bindDependencies(derivation) {
+        // invariant(derivation.dependenciesState !== IDerivationState.NOT_TRACKING, "INTERNAL ERROR bindDependencies expects derivation.dependenciesState !== -1");
+        var prevObserving = derivation.observing;
+        var observing = (derivation.observing = derivation.newObserving);
+        var lowestNewObservingDerivationState = exports.IDerivationState.UP_TO_DATE;
+        // Go through all new observables and check diffValue: (this list can contain duplicates):
+        //   0: first occurrence, change to 1 and keep it
+        //   1: extra occurrence, drop it
+        var i0 = 0, l = derivation.unboundDepsCount;
+        for (var i = 0; i < l; i++) {
+            var dep = observing[i];
+            if (dep.diffValue === 0) {
+                dep.diffValue = 1;
+                if (i0 !== i)
+                    observing[i0] = dep;
+                i0++;
+            }
+            // Upcast is 'safe' here, because if dep is IObservable, `dependenciesState` will be undefined,
+            // not hitting the condition
+            if (dep.dependenciesState > lowestNewObservingDerivationState) {
+                lowestNewObservingDerivationState = dep.dependenciesState;
+            }
+        }
+        observing.length = i0;
+        derivation.newObserving = null; // newObserving shouldn't be needed outside tracking (statement moved down to work around FF bug, see #614)
+        // Go through all old observables and check diffValue: (it is unique after last bindDependencies)
+        //   0: it's not in new observables, unobserve it
+        //   1: it keeps being observed, don't want to notify it. change to 0
+        l = prevObserving.length;
+        while (l--) {
+            var dep = prevObserving[l];
+            if (dep.diffValue === 0) {
+                removeObserver(dep, derivation);
+            }
+            dep.diffValue = 0;
+        }
+        // Go through all new observables and check diffValue: (now it should be unique)
+        //   0: it was set to 0 in last loop. don't need to do anything.
+        //   1: it wasn't observed, let's observe it. set back to 0
+        while (i0--) {
+            var dep = observing[i0];
+            if (dep.diffValue === 1) {
+                dep.diffValue = 0;
+                addObserver(dep, derivation);
+            }
+        }
+        // Some new observed derivations may become stale during this derivation computation
+        // so they have had no chance to propagate staleness (#916)
+        if (lowestNewObservingDerivationState !== exports.IDerivationState.UP_TO_DATE) {
+            derivation.dependenciesState = lowestNewObservingDerivationState;
+            derivation.onBecomeStale();
+        }
+    }
+    function clearObserving(derivation) {
+        // invariant(globalState.inBatch > 0, "INTERNAL ERROR clearObserving should be called only inside batch");
+        var obs = derivation.observing;
+        derivation.observing = [];
+        var i = obs.length;
+        while (i--)
+            removeObserver(obs[i], derivation);
+        derivation.dependenciesState = exports.IDerivationState.NOT_TRACKING;
+    }
+    function untracked(action) {
+        var prev = untrackedStart();
+        try {
+            return action();
+        }
+        finally {
+            untrackedEnd(prev);
+        }
+    }
+    function untrackedStart() {
+        var prev = globalState.trackingDerivation;
+        globalState.trackingDerivation = null;
+        return prev;
+    }
+    function untrackedEnd(prev) {
+        globalState.trackingDerivation = prev;
+    }
+    function allowStateReadsStart(allowStateReads) {
+        var prev = globalState.allowStateReads;
+        globalState.allowStateReads = allowStateReads;
+        return prev;
+    }
+    function allowStateReadsEnd(prev) {
+        globalState.allowStateReads = prev;
+    }
+    /**
+     * needed to keep `lowestObserverState` correct. when changing from (2 or 1) to 0
+     *
+     */
+    function changeDependenciesStateTo0(derivation) {
+        if (derivation.dependenciesState === exports.IDerivationState.UP_TO_DATE)
+            return;
+        derivation.dependenciesState = exports.IDerivationState.UP_TO_DATE;
+        var obs = derivation.observing;
+        var i = obs.length;
+        while (i--)
+            obs[i].lowestObserverState = exports.IDerivationState.UP_TO_DATE;
+    }
+
     function createAction(actionName, fn, ref) {
         if (process.env.NODE_ENV !== "production") {
             invariant(typeof fn === "function", "`action` can only be invoked on functions");
@@ -644,9 +912,11 @@
         var prevDerivation = untrackedStart();
         startBatch();
         var prevAllowStateChanges = allowStateChangesStart(true);
+        var prevAllowStateReads = allowStateReadsStart(true);
         var runInfo = {
             prevDerivation: prevDerivation,
             prevAllowStateChanges: prevAllowStateChanges,
+            prevAllowStateReads: prevAllowStateReads,
             notifySpy: notifySpy,
             startTime: startTime,
             actionId: globalState.nextActionId++,
@@ -664,6 +934,7 @@
             globalState.suppressReactionErrors = true;
         }
         allowStateChangesEnd(runInfo.prevAllowStateChanges);
+        allowStateReadsEnd(runInfo.prevAllowStateReads);
         endBatch();
         untrackedEnd(runInfo.prevDerivation);
         if (runInfo.notifySpy && process.env.NODE_ENV !== "production") {
@@ -1030,247 +1301,6 @@
     }());
     var isComputedValue = createInstanceofPredicate("ComputedValue", ComputedValue);
 
-    (function (IDerivationState) {
-        // before being run or (outside batch and not being observed)
-        // at this point derivation is not holding any data about dependency tree
-        IDerivationState[IDerivationState["NOT_TRACKING"] = -1] = "NOT_TRACKING";
-        // no shallow dependency changed since last computation
-        // won't recalculate derivation
-        // this is what makes mobx fast
-        IDerivationState[IDerivationState["UP_TO_DATE"] = 0] = "UP_TO_DATE";
-        // some deep dependency changed, but don't know if shallow dependency changed
-        // will require to check first if UP_TO_DATE or POSSIBLY_STALE
-        // currently only ComputedValue will propagate POSSIBLY_STALE
-        //
-        // having this state is second big optimization:
-        // don't have to recompute on every dependency change, but only when it's needed
-        IDerivationState[IDerivationState["POSSIBLY_STALE"] = 1] = "POSSIBLY_STALE";
-        // A shallow dependency has changed since last computation and the derivation
-        // will need to recompute when it's needed next.
-        IDerivationState[IDerivationState["STALE"] = 2] = "STALE";
-    })(exports.IDerivationState || (exports.IDerivationState = {}));
-    var TraceMode;
-    (function (TraceMode) {
-        TraceMode[TraceMode["NONE"] = 0] = "NONE";
-        TraceMode[TraceMode["LOG"] = 1] = "LOG";
-        TraceMode[TraceMode["BREAK"] = 2] = "BREAK";
-    })(TraceMode || (TraceMode = {}));
-    var CaughtException = /** @class */ (function () {
-        function CaughtException(cause) {
-            this.cause = cause;
-            // Empty
-        }
-        return CaughtException;
-    }());
-    function isCaughtException(e) {
-        return e instanceof CaughtException;
-    }
-    /**
-     * Finds out whether any dependency of the derivation has actually changed.
-     * If dependenciesState is 1 then it will recalculate dependencies,
-     * if any dependency changed it will propagate it by changing dependenciesState to 2.
-     *
-     * By iterating over the dependencies in the same order that they were reported and
-     * stopping on the first change, all the recalculations are only called for ComputedValues
-     * that will be tracked by derivation. That is because we assume that if the first x
-     * dependencies of the derivation doesn't change then the derivation should run the same way
-     * up until accessing x-th dependency.
-     */
-    function shouldCompute(derivation) {
-        switch (derivation.dependenciesState) {
-            case exports.IDerivationState.UP_TO_DATE:
-                return false;
-            case exports.IDerivationState.NOT_TRACKING:
-            case exports.IDerivationState.STALE:
-                return true;
-            case exports.IDerivationState.POSSIBLY_STALE: {
-                var prevUntracked = untrackedStart(); // no need for those computeds to be reported, they will be picked up in trackDerivedFunction.
-                var obs = derivation.observing, l = obs.length;
-                for (var i = 0; i < l; i++) {
-                    var obj = obs[i];
-                    if (isComputedValue(obj)) {
-                        if (globalState.disableErrorBoundaries) {
-                            obj.get();
-                        }
-                        else {
-                            try {
-                                obj.get();
-                            }
-                            catch (e) {
-                                // we are not interested in the value *or* exception at this moment, but if there is one, notify all
-                                untrackedEnd(prevUntracked);
-                                return true;
-                            }
-                        }
-                        // if ComputedValue `obj` actually changed it will be computed and propagated to its observers.
-                        // and `derivation` is an observer of `obj`
-                        // invariantShouldCompute(derivation)
-                        if (derivation.dependenciesState === exports.IDerivationState.STALE) {
-                            untrackedEnd(prevUntracked);
-                            return true;
-                        }
-                    }
-                }
-                changeDependenciesStateTo0(derivation);
-                untrackedEnd(prevUntracked);
-                return false;
-            }
-        }
-    }
-    // function invariantShouldCompute(derivation: IDerivation) {
-    //     const newDepState = (derivation as any).dependenciesState
-    //     if (
-    //         process.env.NODE_ENV === "production" &&
-    //         (newDepState === IDerivationState.POSSIBLY_STALE ||
-    //             newDepState === IDerivationState.NOT_TRACKING)
-    //     )
-    //         fail("Illegal dependency state")
-    // }
-    function isComputingDerivation() {
-        return globalState.trackingDerivation !== null; // filter out actions inside computations
-    }
-    function checkIfStateModificationsAreAllowed(atom) {
-        var hasObservers = atom.observers.size > 0;
-        // Should never be possible to change an observed observable from inside computed, see #798
-        if (globalState.computationDepth > 0 && hasObservers)
-            fail(process.env.NODE_ENV !== "production" &&
-                "Computed values are not allowed to cause side effects by changing observables that are already being observed. Tried to modify: " + atom.name);
-        // Should not be possible to change observed state outside strict mode, except during initialization, see #563
-        if (!globalState.allowStateChanges && (hasObservers || globalState.enforceActions === "strict"))
-            fail(process.env.NODE_ENV !== "production" &&
-                (globalState.enforceActions
-                    ? "Since strict-mode is enabled, changing observed observable values outside actions is not allowed. Please wrap the code in an `action` if this change is intended. Tried to modify: "
-                    : "Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, the render function of a React component? Tried to modify: ") +
-                    atom.name);
-    }
-    /**
-     * Executes the provided function `f` and tracks which observables are being accessed.
-     * The tracking information is stored on the `derivation` object and the derivation is registered
-     * as observer of any of the accessed observables.
-     */
-    function trackDerivedFunction(derivation, f, context) {
-        // pre allocate array allocation + room for variation in deps
-        // array will be trimmed by bindDependencies
-        changeDependenciesStateTo0(derivation);
-        derivation.newObserving = new Array(derivation.observing.length + 100);
-        derivation.unboundDepsCount = 0;
-        derivation.runId = ++globalState.runId;
-        var prevTracking = globalState.trackingDerivation;
-        globalState.trackingDerivation = derivation;
-        var result;
-        if (globalState.disableErrorBoundaries === true) {
-            result = f.call(context);
-        }
-        else {
-            try {
-                result = f.call(context);
-            }
-            catch (e) {
-                result = new CaughtException(e);
-            }
-        }
-        globalState.trackingDerivation = prevTracking;
-        bindDependencies(derivation);
-        return result;
-    }
-    /**
-     * diffs newObserving with observing.
-     * update observing to be newObserving with unique observables
-     * notify observers that become observed/unobserved
-     */
-    function bindDependencies(derivation) {
-        // invariant(derivation.dependenciesState !== IDerivationState.NOT_TRACKING, "INTERNAL ERROR bindDependencies expects derivation.dependenciesState !== -1");
-        var prevObserving = derivation.observing;
-        var observing = (derivation.observing = derivation.newObserving);
-        var lowestNewObservingDerivationState = exports.IDerivationState.UP_TO_DATE;
-        // Go through all new observables and check diffValue: (this list can contain duplicates):
-        //   0: first occurrence, change to 1 and keep it
-        //   1: extra occurrence, drop it
-        var i0 = 0, l = derivation.unboundDepsCount;
-        for (var i = 0; i < l; i++) {
-            var dep = observing[i];
-            if (dep.diffValue === 0) {
-                dep.diffValue = 1;
-                if (i0 !== i)
-                    observing[i0] = dep;
-                i0++;
-            }
-            // Upcast is 'safe' here, because if dep is IObservable, `dependenciesState` will be undefined,
-            // not hitting the condition
-            if (dep.dependenciesState > lowestNewObservingDerivationState) {
-                lowestNewObservingDerivationState = dep.dependenciesState;
-            }
-        }
-        observing.length = i0;
-        derivation.newObserving = null; // newObserving shouldn't be needed outside tracking (statement moved down to work around FF bug, see #614)
-        // Go through all old observables and check diffValue: (it is unique after last bindDependencies)
-        //   0: it's not in new observables, unobserve it
-        //   1: it keeps being observed, don't want to notify it. change to 0
-        l = prevObserving.length;
-        while (l--) {
-            var dep = prevObserving[l];
-            if (dep.diffValue === 0) {
-                removeObserver(dep, derivation);
-            }
-            dep.diffValue = 0;
-        }
-        // Go through all new observables and check diffValue: (now it should be unique)
-        //   0: it was set to 0 in last loop. don't need to do anything.
-        //   1: it wasn't observed, let's observe it. set back to 0
-        while (i0--) {
-            var dep = observing[i0];
-            if (dep.diffValue === 1) {
-                dep.diffValue = 0;
-                addObserver(dep, derivation);
-            }
-        }
-        // Some new observed derivations may become stale during this derivation computation
-        // so they have had no chance to propagate staleness (#916)
-        if (lowestNewObservingDerivationState !== exports.IDerivationState.UP_TO_DATE) {
-            derivation.dependenciesState = lowestNewObservingDerivationState;
-            derivation.onBecomeStale();
-        }
-    }
-    function clearObserving(derivation) {
-        // invariant(globalState.inBatch > 0, "INTERNAL ERROR clearObserving should be called only inside batch");
-        var obs = derivation.observing;
-        derivation.observing = [];
-        var i = obs.length;
-        while (i--)
-            removeObserver(obs[i], derivation);
-        derivation.dependenciesState = exports.IDerivationState.NOT_TRACKING;
-    }
-    function untracked(action) {
-        var prev = untrackedStart();
-        try {
-            return action();
-        }
-        finally {
-            untrackedEnd(prev);
-        }
-    }
-    function untrackedStart() {
-        var prev = globalState.trackingDerivation;
-        globalState.trackingDerivation = null;
-        return prev;
-    }
-    function untrackedEnd(prev) {
-        globalState.trackingDerivation = prev;
-    }
-    /**
-     * needed to keep `lowestObserverState` correct. when changing from (2 or 1) to 0
-     *
-     */
-    function changeDependenciesStateTo0(derivation) {
-        if (derivation.dependenciesState === exports.IDerivationState.UP_TO_DATE)
-            return;
-        derivation.dependenciesState = exports.IDerivationState.UP_TO_DATE;
-        var obs = derivation.observing;
-        var i = obs.length;
-        while (i--)
-            obs[i].lowestObserverState = exports.IDerivationState.UP_TO_DATE;
-    }
-
     /**
      * These values will persist if global state is reset
      */
@@ -1279,6 +1309,9 @@
         "spyListeners",
         "enforceActions",
         "computedRequiresReaction",
+        "reactionRequiresObservable",
+        "observableRequiresReaction",
+        "allowStateReads",
         "disableErrorBoundaries",
         "runId",
         "UNCHANGED"
@@ -1339,6 +1372,11 @@
              * To ensure that those functions stay pure.
              */
             this.allowStateChanges = true;
+            /**
+             * Is it allowed to read observables at this point?
+             * Used to hold the state needed for `observableRequiresReaction`
+             */
+            this.allowStateReads = true;
             /**
              * If strict mode is enabled, state changes are by default not allowed
              */
@@ -1355,6 +1393,16 @@
              * Warn if computed values are accessed outside a reactive context
              */
             this.computedRequiresReaction = false;
+            /**
+             * (Experimental)
+             * Warn if you try to create to derivation / reactive context without accessing any observable.
+             */
+            this.reactionRequiresObservable = false;
+            /**
+             * (Experimental)
+             * Warn if observables are accessed outside a reactive context
+             */
+            this.observableRequiresReaction = false;
             /**
              * Allows overwriting of computed properties, useful in tests but not prod as it can cause
              * memory leaks. See https://github.com/mobxjs/mobx/issues/1867
@@ -1530,6 +1578,7 @@
         }
     }
     function reportObserved(observable) {
+        checkIfStateReadsAreAllowed(observable);
         var derivation = globalState.trackingDerivation;
         if (derivation !== null) {
             /**
@@ -1643,11 +1692,13 @@
     }
 
     var Reaction = /** @class */ (function () {
-        function Reaction(name, onInvalidate, errorHandler) {
+        function Reaction(name, onInvalidate, errorHandler, requiresObservable) {
             if (name === void 0) { name = "Reaction@" + getNextId(); }
+            if (requiresObservable === void 0) { requiresObservable = false; }
             this.name = name;
             this.onInvalidate = onInvalidate;
             this.errorHandler = errorHandler;
+            this.requiresObservable = requiresObservable;
             this.observing = []; // nodes we are looking at. Our value depends on these nodes
             this.newObserving = [];
             this.dependenciesState = exports.IDerivationState.NOT_TRACKING;
@@ -2010,7 +2061,7 @@
             // normal autorun
             reaction = new Reaction(name, function () {
                 this.track(reactionRunner);
-            }, opts.onError);
+            }, opts.onError, opts.requiresObservable);
         }
         else {
             var scheduler_1 = createSchedulerFromOptions(opts);
@@ -2025,7 +2076,7 @@
                             reaction.track(reactionRunner);
                     });
                 }
-            }, opts.onError);
+            }, opts.onError, opts.requiresObservable);
         }
         function reactionRunner() {
             view(reaction);
@@ -2065,7 +2116,7 @@
                 isScheduled = true;
                 scheduler(reactionRunner);
             }
-        }, opts.onError);
+        }, opts.onError, opts.requiresObservable);
         function reactionRunner() {
             isScheduled = false; // Q: move into reaction runner?
             if (r.isDisposed)
@@ -2128,7 +2179,7 @@
     }
 
     function configure(options) {
-        var enforceActions = options.enforceActions, computedRequiresReaction = options.computedRequiresReaction, computedConfigurable = options.computedConfigurable, disableErrorBoundaries = options.disableErrorBoundaries, reactionScheduler = options.reactionScheduler;
+        var enforceActions = options.enforceActions, computedRequiresReaction = options.computedRequiresReaction, computedConfigurable = options.computedConfigurable, disableErrorBoundaries = options.disableErrorBoundaries, reactionScheduler = options.reactionScheduler, reactionRequiresObservable = options.reactionRequiresObservable, observableRequiresReaction = options.observableRequiresReaction;
         if (options.isolateGlobalState === true) {
             isolateGlobalState();
         }
@@ -2158,6 +2209,13 @@
         if (computedRequiresReaction !== undefined) {
             globalState.computedRequiresReaction = !!computedRequiresReaction;
         }
+        if (reactionRequiresObservable !== undefined) {
+            globalState.reactionRequiresObservable = !!reactionRequiresObservable;
+        }
+        if (observableRequiresReaction !== undefined) {
+            globalState.observableRequiresReaction = !!observableRequiresReaction;
+            globalState.allowStateReads = !globalState.observableRequiresReaction;
+        }
         if (computedConfigurable !== undefined) {
             globalState.computedConfigurable = !!computedConfigurable;
         }