mobx 6.12.1 → 6.12.4

package/dist/mobx.esm.development.js

@@ -433,8 +433,8 @@ var Atom = /*#__PURE__*/function () {
       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;
@@ -1457,6 +1457,17 @@ var ObservableValue = /*#__PURE__*/function (_Atom) {
 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.
  *
@@ -1481,8 +1492,6 @@ var ComputedValue = /*#__PURE__*/function () {
   // 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
 
   /**
@@ -1501,8 +1510,6 @@ var ComputedValue = /*#__PURE__*/function () {
     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;
@@ -1512,8 +1519,7 @@ var ComputedValue = /*#__PURE__*/function () {
     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;
@@ -1554,12 +1560,14 @@ var ComputedValue = /*#__PURE__*/function () {
       });
     }
   }
+  // 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 &&
@@ -1592,14 +1600,14 @@ var ComputedValue = /*#__PURE__*/function () {
   };
   _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_);
@@ -1627,7 +1635,7 @@ var ComputedValue = /*#__PURE__*/function () {
     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;
@@ -1645,7 +1653,7 @@ var ComputedValue = /*#__PURE__*/function () {
       }
     }
     allowStateChangesEnd(prev);
-    this.isComputing_ = false;
+    this.isComputing = false;
     return res;
   };
   _proto.suspend_ = function suspend_() {
@@ -1697,8 +1705,45 @@ var ComputedValue = /*#__PURE__*/function () {
   _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_;
@@ -2100,9 +2145,9 @@ function removeObserver(observable, node) {
 }
 
 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);
   }
 }
@@ -2121,11 +2166,11 @@ function endBatch() {
     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) {
@@ -2151,12 +2196,12 @@ function reportObserved(observable) {
       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);
   }