(cherry-pick) add allowStateChangesInsideComputed to allow changes in…

…side a computed value (#1706)

* make allowStateChanges allow changes inside computed value

in order to fix MST mobxjs/mobx-state-tree#967

* added allowStateChangeInsideComputed

* added unit test

* small unit test error

* safer implementation

* Alternative solution

* Revert "Alternative solution"

This reverts commit e15bc78.

* improve unit test

* Changed to more predictable restoration

src/core/action.ts

@@ -96,3 +96,15 @@ export function allowStateChangesStart(allowStateChanges: boolean) {
 export function allowStateChangesEnd(prev: boolean) {
     globalState.allowStateChanges = prev
 }
+
+export function allowStateChangesInsideComputed<T>(func: () => T): T {
+    const prev = globalState.computationDepth
+    globalState.computationDepth = 0
+    let res: T
+    try {
+        res = func()
+    } finally {
+        globalState.computationDepth = prev
+    }
+    return res
+}

src/core/globalstate.ts

@@ -75,6 +75,7 @@ export class MobXGlobals {
      * To ensure that those functions stay pure.
      */
     allowStateChanges = true
+
     /**
      * If strict mode is enabled, state changes are by default not allowed
      */

src/mobx.ts

@@ -112,7 +112,10 @@ export {
     getGlobalState as _getGlobalState
 } from "./core/globalstate"
 export { getDebugName, getAtom, getAdministration as _getAdministration } from "./types/type-utils"
-export { allowStateChanges as _allowStateChanges } from "./core/action"
+export {
+    allowStateChanges as _allowStateChanges,
+    allowStateChangesInsideComputed as _allowStateChangesInsideComputed
+} from "./core/action"
 export { Lambda, isArrayLike } from "./utils/utils"
 export { isComputingDerivation as _isComputingDerivation } from "./core/derivation"
 export { onReactionError } from "./core/reaction"

test/base/action.js

@@ -173,6 +173,44 @@ test("should be possible to change unobserved state in an action called from com
     mobx._resetGlobalState()
 })
 
+test("should be possible to change observed state in an action called from computed if run inside _allowStateChangesInsideComputed", () => {
+    const a = mobx.observable.box(2)
+    const d = mobx.autorun(() => {
+        a.get()
+    })
+
+    const testAction = mobx.action(() => {
+        mobx._allowStateChangesInsideComputed(() => {
+            a.set(3)
+            // a second level computed should throw
+            expect(() => c2.get()).toThrowError(
+                /Computed values are not allowed to cause side effects by changing observables that are already being observed/
+            )
+        })
+        expect(a.get()).toBe(3)
+        expect(() => {
+            a.set(4)
+        }).toThrowError(
+            /Computed values are not allowed to cause side effects by changing observables that are already being observed/
+        )
+    })
+
+    const c = mobx.computed(() => {
+        testAction()
+        return a.get()
+    })
+
+    const c2 = mobx.computed(() => {
+        a.set(6)
+        return a.get()
+    })
+
+    c.get()
+
+    mobx._resetGlobalState()
+    d()
+})
+
 test("should not be possible to change observed state in an action called from computed", () => {
     var a = mobx.observable.box(2)
     var d = mobx.autorun(() => {

test/base/api.js

@@ -2,14 +2,11 @@ import * as fs from "fs"
 var mobx = require("../../src/mobx.ts")
 
 test("correct api should be exposed", function() {
-    expect(
-        Object.keys(mobx)
-            .filter(key => mobx[key] !== undefined)
-            .sort()
-    ).toEqual(
+    expect(Object.keys(mobx).filter(key => mobx[key] !== undefined).sort()).toEqual(
         [
             "action",
             "_allowStateChanges",
+            "_allowStateChangesInsideComputed",
             "autorun",
             "comparer",
             "computed",