mobx 6.13.0 → 6.13.2

package/dist/mobx.esm.js

@@ -203,15 +203,24 @@ function createInstanceofPredicate(name, theClass) {
     return isObject(x) && x[propName] === true;
   };
 }
+/**
+ * Yields true for both native and observable Map, even across different windows.
+ */
 function isES6Map(thing) {
   return thing != null && Object.prototype.toString.call(thing) === "[object Map]";
 }
+/**
+ * Makes sure a Map is an instance of non-inherited native or observable Map.
+ */
 function isPlainES6Map(thing) {
   var mapProto = Object.getPrototypeOf(thing);
   var objectProto = Object.getPrototypeOf(mapProto);
   var nullProto = Object.getPrototypeOf(objectProto);
   return nullProto === null;
 }
+/**
+ * Yields true for both native and observable Set, even across different windows.
+ */
 function isES6Set(thing) {
   return thing != null && Object.prototype.toString.call(thing) === "[object Set]";
 }
@@ -263,6 +272,17 @@ var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function get
   });
   return res;
 };
+function getFlag(flags, mask) {
+  return !!(flags & mask);
+}
+function setFlag(flags, mask, newValue) {
+  if (newValue) {
+    flags |= mask;
+  } else {
+    flags &= ~mask;
+  }
+  return flags;
+}
 
 function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
@@ -415,11 +435,8 @@ var Atom = /*#__PURE__*/function () {
       name_ = process.env.NODE_ENV !== "production" ? "Atom@" + getNextId() : "Atom";
     }
     this.name_ = void 0;
-    this.isPendingUnobservation = false;
-    // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
-    this.isBeingObserved = false;
+    this.flags_ = 0;
     this.observers_ = new Set();
-    this.diffValue_ = 0;
     this.lastAccessedBy_ = 0;
     this.lowestObserverState_ = IDerivationState_.NOT_TRACKING_;
     // onBecomeObservedListeners
@@ -428,6 +445,7 @@ var Atom = /*#__PURE__*/function () {
     this.onBUOL = void 0;
     this.name_ = name_;
   }
+  // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
   var _proto = Atom.prototype;
   _proto.onBO = function onBO() {
     if (this.onBOL) {
@@ -461,8 +479,35 @@ var Atom = /*#__PURE__*/function () {
   _proto.toString = function toString() {
     return this.name_;
   };
-  return Atom;
+  return _createClass(Atom, [{
+    key: "isBeingObserved",
+    get: function get() {
+      return getFlag(this.flags_, Atom.isBeingObservedMask_);
+    },
+    set: function set(newValue) {
+      this.flags_ = setFlag(this.flags_, Atom.isBeingObservedMask_, newValue);
+    }
+  }, {
+    key: "isPendingUnobservation",
+    get: function get() {
+      return getFlag(this.flags_, Atom.isPendingUnobservationMask_);
+    },
+    set: function set(newValue) {
+      this.flags_ = setFlag(this.flags_, Atom.isPendingUnobservationMask_, newValue);
+    }
+  }, {
+    key: "diffValue",
+    get: function get() {
+      return getFlag(this.flags_, Atom.diffValueMask_) ? 1 : 0;
+    },
+    set: function set(newValue) {
+      this.flags_ = setFlag(this.flags_, Atom.diffValueMask_, newValue === 1 ? true : false);
+    }
+  }]);
 }();
+Atom.isBeingObservedMask_ = 1;
+Atom.isPendingUnobservationMask_ = 2;
+Atom.diffValueMask_ = 4;
 var isAtom = /*#__PURE__*/createInstanceofPredicate("Atom", Atom);
 function createAtom(name, onBecomeObservedHandler, onBecomeUnobservedHandler) {
   if (onBecomeObservedHandler === void 0) {
@@ -1430,17 +1475,6 @@ var ObservableValue = /*#__PURE__*/function (_Atom) {
 }(Atom);
 var isObservableValue = /*#__PURE__*/createInstanceofPredicate("ObservableValue", ObservableValue);
 
-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.
  *
@@ -1480,7 +1514,6 @@ var ComputedValue = /*#__PURE__*/function () {
     this.newObserving_ = null;
     // during tracking it's an array with new observed observers
     this.observers_ = new Set();
-    this.diffValue_ = 0;
     this.runId_ = 0;
     this.lastAccessedBy_ = 0;
     this.lowestObserverState_ = IDerivationState_.UP_TO_DATE_;
@@ -1710,12 +1743,21 @@ var ComputedValue = /*#__PURE__*/function () {
     set: function set(newValue) {
       this.flags_ = setFlag(this.flags_, ComputedValue.isPendingUnobservationMask_, newValue);
     }
+  }, {
+    key: "diffValue",
+    get: function get() {
+      return getFlag(this.flags_, ComputedValue.diffValueMask_) ? 1 : 0;
+    },
+    set: function set(newValue) {
+      this.flags_ = setFlag(this.flags_, ComputedValue.diffValueMask_, newValue === 1 ? true : false);
+    }
   }]);
 }();
 ComputedValue.isComputingMask_ = 1;
 ComputedValue.isRunningSetterMask_ = 2;
 ComputedValue.isBeingObservedMask_ = 4;
 ComputedValue.isPendingUnobservationMask_ = 8;
+ComputedValue.diffValueMask_ = 16;
 var isComputedValue = /*#__PURE__*/createInstanceofPredicate("ComputedValue", ComputedValue);
 
 var IDerivationState_;
@@ -1890,8 +1932,8 @@ function bindDependencies(derivation) {
     l = derivation.unboundDepsCount_;
   for (var i = 0; i < l; i++) {
     var dep = observing[i];
-    if (dep.diffValue_ === 0) {
-      dep.diffValue_ = 1;
+    if (dep.diffValue === 0) {
+      dep.diffValue = 1;
       if (i0 !== i) {
         observing[i0] = dep;
       }
@@ -1911,18 +1953,18 @@ function bindDependencies(derivation) {
   l = prevObserving.length;
   while (l--) {
     var _dep = prevObserving[l];
-    if (_dep.diffValue_ === 0) {
+    if (_dep.diffValue === 0) {
       removeObserver(_dep, derivation);
     }
-    _dep.diffValue_ = 0;
+    _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 _dep2 = observing[i0];
-    if (_dep2.diffValue_ === 1) {
-      _dep2.diffValue_ = 0;
+    if (_dep2.diffValue === 1) {
+      _dep2.diffValue = 0;
       addObserver(_dep2, derivation);
     }
   }
@@ -2375,13 +2417,9 @@ var Reaction = /*#__PURE__*/function () {
     // nodes we are looking at. Our value depends on these nodes
     this.newObserving_ = [];
     this.dependenciesState_ = IDerivationState_.NOT_TRACKING_;
-    this.diffValue_ = 0;
     this.runId_ = 0;
     this.unboundDepsCount_ = 0;
-    this.isDisposed_ = false;
-    this.isScheduled_ = false;
-    this.isTrackPending_ = false;
-    this.isRunning_ = false;
+    this.flags_ = 0;
     this.isTracing_ = TraceMode.NONE;
     this.name_ = name_;
     this.onInvalidate_ = onInvalidate_;
@@ -2393,29 +2431,26 @@ var Reaction = /*#__PURE__*/function () {
     this.schedule_();
   };
   _proto.schedule_ = function schedule_() {
-    if (!this.isScheduled_) {
-      this.isScheduled_ = true;
+    if (!this.isScheduled) {
+      this.isScheduled = true;
       globalState.pendingReactions.push(this);
       runReactions();
     }
-  };
-  _proto.isScheduled = function isScheduled() {
-    return this.isScheduled_;
   }
   /**
    * internal, use schedule() if you intend to kick off a reaction
    */;
   _proto.runReaction_ = function runReaction_() {
-    if (!this.isDisposed_) {
+    if (!this.isDisposed) {
       startBatch();
-      this.isScheduled_ = false;
+      this.isScheduled = false;
       var prev = globalState.trackingContext;
       globalState.trackingContext = this;
       if (shouldCompute(this)) {
-        this.isTrackPending_ = true;
+        this.isTrackPending = true;
         try {
           this.onInvalidate_();
-          if (process.env.NODE_ENV !== "production" && this.isTrackPending_ && isSpyEnabled()) {
+          if (process.env.NODE_ENV !== "production" && this.isTrackPending && isSpyEnabled()) {
             // onInvalidate didn't trigger track right away..
             spyReport({
               name: this.name_,
@@ -2431,7 +2466,7 @@ var Reaction = /*#__PURE__*/function () {
     }
   };
   _proto.track = function track(fn) {
-    if (this.isDisposed_) {
+    if (this.isDisposed) {
       return;
       // console.warn("Reaction already disposed") // Note: Not a warning / error in mobx 4 either
     }
@@ -2445,14 +2480,14 @@ var Reaction = /*#__PURE__*/function () {
         type: "reaction"
       });
     }
-    this.isRunning_ = true;
+    this.isRunning = true;
     var prevReaction = globalState.trackingContext; // reactions could create reactions...
     globalState.trackingContext = this;
     var result = trackDerivedFunction(this, fn, undefined);
     globalState.trackingContext = prevReaction;
-    this.isRunning_ = false;
-    this.isTrackPending_ = false;
-    if (this.isDisposed_) {
+    this.isRunning = false;
+    this.isTrackPending = false;
+    if (this.isDisposed) {
       // disposed during last run. Clean up everything that was bound after the dispose call.
       clearObserving(this);
     }
@@ -2495,9 +2530,9 @@ var Reaction = /*#__PURE__*/function () {
     });
   };
   _proto.dispose = function dispose() {
-    if (!this.isDisposed_) {
-      this.isDisposed_ = true;
-      if (!this.isRunning_) {
+    if (!this.isDisposed) {
+      this.isDisposed = true;
+      if (!this.isRunning) {
         // if disposed while running, clean up later. Maybe not optimal, but rare case
         startBatch();
         clearObserving(this);
@@ -2524,8 +2559,53 @@ var Reaction = /*#__PURE__*/function () {
     }
     trace(this, enterBreakPoint);
   };
-  return Reaction;
+  return _createClass(Reaction, [{
+    key: "isDisposed",
+    get: function get() {
+      return getFlag(this.flags_, Reaction.isDisposedMask_);
+    },
+    set: function set(newValue) {
+      this.flags_ = setFlag(this.flags_, Reaction.isDisposedMask_, newValue);
+    }
+  }, {
+    key: "isScheduled",
+    get: function get() {
+      return getFlag(this.flags_, Reaction.isScheduledMask_);
+    },
+    set: function set(newValue) {
+      this.flags_ = setFlag(this.flags_, Reaction.isScheduledMask_, newValue);
+    }
+  }, {
+    key: "isTrackPending",
+    get: function get() {
+      return getFlag(this.flags_, Reaction.isTrackPendingMask_);
+    },
+    set: function set(newValue) {
+      this.flags_ = setFlag(this.flags_, Reaction.isTrackPendingMask_, newValue);
+    }
+  }, {
+    key: "isRunning",
+    get: function get() {
+      return getFlag(this.flags_, Reaction.isRunningMask_);
+    },
+    set: function set(newValue) {
+      this.flags_ = setFlag(this.flags_, Reaction.isRunningMask_, newValue);
+    }
+  }, {
+    key: "diffValue",
+    get: function get() {
+      return getFlag(this.flags_, Reaction.diffValueMask_) ? 1 : 0;
+    },
+    set: function set(newValue) {
+      this.flags_ = setFlag(this.flags_, Reaction.diffValueMask_, newValue === 1 ? true : false);
+    }
+  }]);
 }();
+Reaction.isDisposedMask_ = 1;
+Reaction.isScheduledMask_ = 2;
+Reaction.isTrackPendingMask_ = 4;
+Reaction.isRunningMask_ = 8;
+Reaction.diffValueMask_ = 16;
 function onReactionError(handler) {
   globalState.globalReactionErrorHandlers.push(handler);
   return function () {
@@ -2731,7 +2811,7 @@ function autorun(view, opts) {
         isScheduled = true;
         scheduler(function () {
           isScheduled = false;
-          if (!reaction.isDisposed_) {
+          if (!reaction.isDisposed) {
             reaction.track(reactionRunner);
           }
         });
@@ -2785,7 +2865,7 @@ function reaction(expression, effect, opts) {
   }, opts.onError, opts.requiresObservable);
   function reactionRunner() {
     isScheduled = false;
-    if (r.isDisposed_) {
+    if (r.isDisposed) {
       return;
     }
     var changed = false;
@@ -3415,7 +3495,7 @@ function _when(predicate, effect, opts) {
   if (typeof opts.timeout === "number") {
     var error = new Error("WHEN_TIMEOUT");
     timeoutHandle = setTimeout(function () {
-      if (!disposer[$mobx].isDisposed_) {
+      if (!disposer[$mobx].isDisposed) {
         disposer();
         if (opts.onError) {
           opts.onError(error);
@@ -4721,7 +4801,7 @@ var ObservableSet = /*#__PURE__*/function () {
     });
   };
   _proto.intersection = function intersection(otherSet) {
-    if (isES6Set(otherSet)) {
+    if (isES6Set(otherSet) && !isObservableSet(otherSet)) {
       return otherSet.intersection(this);
     } else {
       var dehancedSet = new Set(this);
@@ -4729,7 +4809,7 @@ var ObservableSet = /*#__PURE__*/function () {
     }
   };
   _proto.union = function union(otherSet) {
-    if (isES6Set(otherSet)) {
+    if (isES6Set(otherSet) && !isObservableSet(otherSet)) {
       return otherSet.union(this);
     } else {
       var dehancedSet = new Set(this);
@@ -4740,7 +4820,7 @@ var ObservableSet = /*#__PURE__*/function () {
     return new Set(this).difference(otherSet);
   };
   _proto.symmetricDifference = function symmetricDifference(otherSet) {
-    if (isES6Set(otherSet)) {
+    if (isES6Set(otherSet) && !isObservableSet(otherSet)) {
       return otherSet.symmetricDifference(this);
     } else {
       var dehancedSet = new Set(this);
@@ -4754,7 +4834,7 @@ var ObservableSet = /*#__PURE__*/function () {
     return new Set(this).isSupersetOf(otherSet);
   };
   _proto.isDisjointFrom = function isDisjointFrom(otherSet) {
-    if (isES6Set(otherSet)) {
+    if (isES6Set(otherSet) && !isObservableSet(otherSet)) {
       return otherSet.isDisjointFrom(this);
     } else {
       var dehancedSet = new Set(this);