add allowStateChangesInsideComputed to allow changes inside a compute…

…d 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

@@ -104,3 +104,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

@@ -72,6 +72,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

@@ -136,6 +136,7 @@ export {
     getAtom,
     getAdministration as _getAdministration,
     allowStateChanges as _allowStateChanges,
+    allowStateChangesInsideComputed as _allowStateChangesInsideComputed,
     Lambda,
     isArrayLike,
     $mobx,

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

@@ -11,6 +11,7 @@ test("correct api should be exposed", function() {
             "$mobx", // adminstration symbol
             "action",
             "_allowStateChanges",
+            "_allowStateChangesInsideComputed",
             "autorun",
             "comparer",
             "computed",