mobx 6.13.0 → 6.13.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # mobx
 
+## 6.13.1
+
+### Patch Changes
+
+-   [`5e711e0b4737fd6b5b3c6f9b32afd4f195bc5fc3`](https://github.com/mobxjs/mobx/commit/5e711e0b4737fd6b5b3c6f9b32afd4f195bc5fc3) [#3901](https://github.com/mobxjs/mobx/pull/3901) Thanks [@peterm-canva](https://github.com/peterm-canva)! - Shrink Atom and Reaction using a bitfield
+
 ## 6.13.0
 
 ### Minor Changes

package/dist/core/atom.d.ts

@@ -6,10 +6,11 @@ export interface IAtom extends IObservable {
 }
 export declare class Atom implements IAtom {
     name_: string;
-    isPendingUnobservation: boolean;
-    isBeingObserved: boolean;
+    private static readonly isBeingObservedMask_;
+    private static readonly isPendingUnobservationMask_;
+    private static readonly diffValueMask_;
+    private flags_;
     observers_: Set<IDerivation>;
-    diffValue_: number;
     lastAccessedBy_: number;
     lowestObserverState_: IDerivationState_;
     /**
@@ -17,6 +18,12 @@ export declare class Atom implements IAtom {
      * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.
      */
     constructor(name_?: string);
+    get isBeingObserved(): boolean;
+    set isBeingObserved(newValue: boolean);
+    get isPendingUnobservation(): boolean;
+    set isPendingUnobservation(newValue: boolean);
+    get diffValue(): 0 | 1;
+    set diffValue(newValue: 0 | 1);
     onBOL: Set<Lambda> | undefined;
     onBUOL: Set<Lambda> | undefined;
     onBO(): void;

package/dist/core/computedvalue.d.ts

@@ -44,7 +44,6 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
     observing_: IObservable[];
     newObserving_: null;
     observers_: Set<IDerivation>;
-    diffValue_: number;
     runId_: number;
     lastAccessedBy_: number;
     lowestObserverState_: IDerivationState_;
@@ -56,6 +55,7 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
     private static readonly isRunningSetterMask_;
     private static readonly isBeingObservedMask_;
     private static readonly isPendingUnobservationMask_;
+    private static readonly diffValueMask_;
     private flags_;
     derivation: () => T;
     setter_?: (value: T) => void;
@@ -90,6 +90,8 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
     set isBeingObserved(newValue: boolean);
     get isPendingUnobservation(): boolean;
     set isPendingUnobservation(newValue: boolean);
+    get diffValue(): 0 | 1;
+    set diffValue(newValue: 0 | 1);
     /**
      * Returns the current value of this computed value.
      * Will evaluate its computation first if needed.

package/dist/core/observable.d.ts

@@ -4,7 +4,7 @@ export interface IDepTreeNode {
     observing_?: IObservable[];
 }
 export interface IObservable extends IDepTreeNode {
-    diffValue_: number;
+    diffValue: number;
     /**
      * Id of the derivation *run* that last accessed this observable.
      * If this id equals the *run* id of the current derivation,

package/dist/core/reaction.d.ts

@@ -33,18 +33,28 @@ export declare class Reaction implements IDerivation, IReactionPublic {
     observing_: IObservable[];
     newObserving_: IObservable[];
     dependenciesState_: IDerivationState_;
-    diffValue_: number;
     runId_: number;
     unboundDepsCount_: number;
-    isDisposed_: boolean;
-    isScheduled_: boolean;
-    isTrackPending_: boolean;
-    isRunning_: boolean;
+    private static readonly isDisposedMask_;
+    private static readonly isScheduledMask_;
+    private static readonly isTrackPendingMask_;
+    private static readonly isRunningMask_;
+    private static readonly diffValueMask_;
+    private flags_;
     isTracing_: TraceMode;
     constructor(name_: string, onInvalidate_: () => void, errorHandler_?: ((error: any, derivation: IDerivation) => void) | undefined, requiresObservable_?: any);
+    get isDisposed(): boolean;
+    set isDisposed(newValue: boolean);
+    get isScheduled(): boolean;
+    set isScheduled(newValue: boolean);
+    get isTrackPending(): boolean;
+    set isTrackPending(newValue: boolean);
+    get isRunning(): boolean;
+    set isRunning(newValue: boolean);
+    get diffValue(): 0 | 1;
+    set diffValue(newValue: 0 | 1);
     onBecomeStale_(): void;
     schedule_(): void;
-    isScheduled(): boolean;
     /**
      * internal, use schedule() if you intend to kick off a reaction
      */

package/dist/mobx.cjs.development.js

@@ -266,6 +266,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);
@@ -418,11 +429,8 @@ var Atom = /*#__PURE__*/function () {
       name_ =  "Atom@" + getNextId() ;
     }
     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
@@ -431,6 +439,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) {
@@ -464,8 +473,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) {
@@ -1433,17 +1469,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.
  *
@@ -1483,7 +1508,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 +1734,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_;
@@ -1884,8 +1917,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;
       }
@@ -1905,18 +1938,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);
     }
   }
@@ -2369,13 +2402,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_;
@@ -2387,29 +2416,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 ("development" !== "production" && this.isTrackPending_ && isSpyEnabled()) {
+          if ("development" !== "production" && this.isTrackPending && isSpyEnabled()) {
             // onInvalidate didn't trigger track right away..
             spyReport({
               name: this.name_,
@@ -2425,7 +2451,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
     }
@@ -2439,14 +2465,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);
     }
@@ -2489,9 +2515,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);
@@ -2518,8 +2544,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 () {
@@ -2713,7 +2784,7 @@ function autorun(view, opts) {
         isScheduled = true;
         scheduler(function () {
           isScheduled = false;
-          if (!reaction.isDisposed_) {
+          if (!reaction.isDisposed) {
             reaction.track(reactionRunner);
           }
         });
@@ -2767,7 +2838,7 @@ function reaction(expression, effect, opts) {
   }, opts.onError, opts.requiresObservable);
   function reactionRunner() {
     isScheduled = false;
-    if (r.isDisposed_) {
+    if (r.isDisposed) {
       return;
     }
     var changed = false;
@@ -3394,7 +3465,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);