mobx 6.12.1 → 6.12.4

package/dist/mobx.umd.development.js

@@ -439,8 +439,8 @@
           name_ =  "Atom@" + getNextId() ;
         }
         this.name_ = void 0;
-        this.isPendingUnobservation_ = false;
-        this.isBeingObserved_ = false;
+        this.isPendingUnobservation = false;
+        this.isBeingObserved = false;
         this.observers_ = new Set();
         this.diffValue_ = 0;
         this.lastAccessedBy_ = 0;
@@ -1463,6 +1463,17 @@
     var isObservableValue = /*#__PURE__*/createInstanceofPredicate("ObservableValue", ObservableValue);
 
     var _Symbol$toPrimitive$1;
+    function getFlag(flags, mask) {
+      return !!(flags & mask);
+    }
+    function setFlag(flags, mask, newValue) {
+      if (newValue) {
+        flags |= mask;
+      } else {
+        flags &= ~mask;
+      }
+      return flags;
+    }
     /**
      * A node in the state dependency root that observes other nodes, and can be observed itself.
      *
@@ -1487,8 +1498,6 @@
       // nodes we are looking at. Our value depends on these nodes
       // during tracking it's an array with new observed observers
 
-      // to check for cycles
-
       // N.B: unminified as it is used by MST
 
       /**
@@ -1507,8 +1516,6 @@
         this.dependenciesState_ = IDerivationState_.NOT_TRACKING_;
         this.observing_ = [];
         this.newObserving_ = null;
-        this.isBeingObserved_ = false;
-        this.isPendingUnobservation_ = false;
         this.observers_ = new Set();
         this.diffValue_ = 0;
         this.runId_ = 0;
@@ -1518,8 +1525,7 @@
         this.value_ = new CaughtException(null);
         this.name_ = void 0;
         this.triggeredBy_ = void 0;
-        this.isComputing_ = false;
-        this.isRunningSetter_ = false;
+        this.flags_ = 0;
         this.derivation = void 0;
         this.setter_ = void 0;
         this.isTracing_ = TraceMode.NONE;
@@ -1560,12 +1566,14 @@
           });
         }
       }
+      // to check for cycles
+      ;
       /**
        * Returns the current value of this computed value.
        * Will evaluate its computation first if needed.
-       */;
+       */
       _proto.get = function get() {
-        if (this.isComputing_) {
+        if (this.isComputing) {
           die(32, this.name_, this.derivation);
         }
         if (globalState.inBatch === 0 &&
@@ -1598,14 +1606,14 @@
       };
       _proto.set = function set(value) {
         if (this.setter_) {
-          if (this.isRunningSetter_) {
+          if (this.isRunningSetter) {
             die(33, this.name_);
           }
-          this.isRunningSetter_ = true;
+          this.isRunningSetter = true;
           try {
             this.setter_.call(this.scope_, value);
           } finally {
-            this.isRunningSetter_ = false;
+            this.isRunningSetter = false;
           }
         } else {
           die(34, this.name_);
@@ -1633,7 +1641,7 @@
         return changed;
       };
       _proto.computeValue_ = function computeValue_(track) {
-        this.isComputing_ = true;
+        this.isComputing = true;
         // don't allow state changes during computation
         var prev = allowStateChangesStart(false);
         var res;
@@ -1651,7 +1659,7 @@
           }
         }
         allowStateChangesEnd(prev);
-        this.isComputing_ = false;
+        this.isComputing = false;
         return res;
       };
       _proto.suspend_ = function suspend_() {
@@ -1703,8 +1711,45 @@
       _proto[_Symbol$toPrimitive$1] = function () {
         return this.valueOf();
       };
+      _createClass(ComputedValue, [{
+        key: "isComputing",
+        get: function get() {
+          return getFlag(this.flags_, ComputedValue.isComputingMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, ComputedValue.isComputingMask_, newValue);
+        }
+      }, {
+        key: "isRunningSetter",
+        get: function get() {
+          return getFlag(this.flags_, ComputedValue.isRunningSetterMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, ComputedValue.isRunningSetterMask_, newValue);
+        }
+      }, {
+        key: "isBeingObserved",
+        get: function get() {
+          return getFlag(this.flags_, ComputedValue.isBeingObservedMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, ComputedValue.isBeingObservedMask_, newValue);
+        }
+      }, {
+        key: "isPendingUnobservation",
+        get: function get() {
+          return getFlag(this.flags_, ComputedValue.isPendingUnobservationMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, ComputedValue.isPendingUnobservationMask_, newValue);
+        }
+      }]);
       return ComputedValue;
     }();
+    ComputedValue.isComputingMask_ = 1;
+    ComputedValue.isRunningSetterMask_ = 2;
+    ComputedValue.isBeingObservedMask_ = 4;
+    ComputedValue.isPendingUnobservationMask_ = 8;
     var isComputedValue = /*#__PURE__*/createInstanceofPredicate("ComputedValue", ComputedValue);
 
     var IDerivationState_;
@@ -2106,9 +2151,9 @@
     }
 
     function queueForUnobservation(observable) {
-      if (observable.isPendingUnobservation_ === false) {
+      if (observable.isPendingUnobservation === false) {
         // invariant(observable._observers.length === 0, "INTERNAL ERROR, should only queue for unobservation unobserved observables");
-        observable.isPendingUnobservation_ = true;
+        observable.isPendingUnobservation = true;
         globalState.pendingUnobservations.push(observable);
       }
     }
@@ -2127,11 +2172,11 @@
         var list = globalState.pendingUnobservations;
         for (var i = 0; i < list.length; i++) {
           var observable = list[i];
-          observable.isPendingUnobservation_ = false;
+          observable.isPendingUnobservation = false;
           if (observable.observers_.size === 0) {
-            if (observable.isBeingObserved_) {
+            if (observable.isBeingObserved) {
               // if this observable had reactive observers, trigger the hooks
-              observable.isBeingObserved_ = false;
+              observable.isBeingObserved = false;
               observable.onBUO();
             }
             if (observable instanceof ComputedValue) {
@@ -2157,12 +2202,12 @@
           observable.lastAccessedBy_ = derivation.runId_;
           // Tried storing newObserving, or observing, or both as Set, but performance didn't come close...
           derivation.newObserving_[derivation.unboundDepsCount_++] = observable;
-          if (!observable.isBeingObserved_ && globalState.trackingContext) {
-            observable.isBeingObserved_ = true;
+          if (!observable.isBeingObserved && globalState.trackingContext) {
+            observable.isBeingObserved = true;
             observable.onBO();
           }
         }
-        return observable.isBeingObserved_;
+        return observable.isBeingObserved;
       } else if (observable.observers_.size === 0 && globalState.inBatch > 0) {
         queueForUnobservation(observable);
       }