mobx 6.12.3 → 6.12.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "6.12.3",
+    "version": "6.12.4",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "main": "dist/index.js",

package/src/core/atom.ts

@@ -22,8 +22,8 @@ export interface IAtom extends IObservable {
 }
 
 export class Atom implements IAtom {
-    isPendingUnobservation_ = false // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
-    isBeingObserved_ = false
+    isPendingUnobservation = false // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
+    isBeingObserved = false
     observers_ = new Set<IDerivation>()
 
     diffValue_ = 0

package/src/core/computedvalue.ts

@@ -56,6 +56,18 @@ export type IComputedDidChange<T = any> = {
     oldValue: T | undefined
 }
 
+function getFlag(flags: number, mask: number) {
+    return !!(flags & mask)
+}
+function setFlag(flags: number, mask: number, newValue: boolean): number {
+    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.
  *
@@ -79,8 +91,6 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     dependenciesState_ = IDerivationState_.NOT_TRACKING_
     observing_: IObservable[] = [] // nodes we are looking at. Our value depends on these nodes
     newObserving_ = null // during tracking it's an array with new observed observers
-    isBeingObserved_ = false
-    isPendingUnobservation_: boolean = false
     observers_ = new Set<IDerivation>()
     diffValue_ = 0
     runId_ = 0
@@ -90,8 +100,13 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     protected value_: T | undefined | CaughtException = new CaughtException(null)
     name_: string
     triggeredBy_?: string
-    isComputing_: boolean = false // to check for cycles
-    isRunningSetter_: boolean = false
+
+    private static readonly isComputingMask_ = 0b0001
+    private static readonly isRunningSetterMask_ = 0b0010
+    private static readonly isBeingObservedMask_ = 0b0100
+    private static readonly isPendingUnobservationMask_ = 0b1000
+    private flags_ = 0b0000
+
     derivation: () => T // N.B: unminified as it is used by MST
     setter_?: (value: T) => void
     isTracing_: TraceMode = TraceMode.NONE
@@ -153,12 +168,41 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
         }
     }
 
+    // to check for cycles
+    private get isComputing(): boolean {
+        return getFlag(this.flags_, ComputedValue.isComputingMask_)
+    }
+    private set isComputing(newValue: boolean) {
+        this.flags_ = setFlag(this.flags_, ComputedValue.isComputingMask_, newValue)
+    }
+
+    private get isRunningSetter(): boolean {
+        return getFlag(this.flags_, ComputedValue.isRunningSetterMask_)
+    }
+    private set isRunningSetter(newValue: boolean) {
+        this.flags_ = setFlag(this.flags_, ComputedValue.isRunningSetterMask_, newValue)
+    }
+
+    get isBeingObserved(): boolean {
+        return getFlag(this.flags_, ComputedValue.isBeingObservedMask_)
+    }
+    set isBeingObserved(newValue: boolean) {
+        this.flags_ = setFlag(this.flags_, ComputedValue.isBeingObservedMask_, newValue)
+    }
+
+    get isPendingUnobservation(): boolean {
+        return getFlag(this.flags_, ComputedValue.isPendingUnobservationMask_)
+    }
+    set isPendingUnobservation(newValue: boolean) {
+        this.flags_ = setFlag(this.flags_, ComputedValue.isPendingUnobservationMask_, newValue)
+    }
+
     /**
      * Returns the current value of this computed value.
      * Will evaluate its computation first if needed.
      */
     public get(): T {
-        if (this.isComputing_) {
+        if (this.isComputing) {
             die(32, this.name_, this.derivation)
         }
         if (
@@ -196,14 +240,14 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
 
     public set(value: T) {
         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_)
@@ -242,7 +286,7 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     }
 
     computeValue_(track: boolean) {
-        this.isComputing_ = true
+        this.isComputing = true
         // don't allow state changes during computation
         const prev = allowStateChangesStart(false)
         let res: T | CaughtException
@@ -260,7 +304,7 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
             }
         }
         allowStateChangesEnd(prev)
-        this.isComputing_ = false
+        this.isComputing = false
         return res
     }
 

package/src/core/observable.ts

@@ -24,10 +24,10 @@ export interface IObservable extends IDepTreeNode {
      * the dependency is already established
      */
     lastAccessedBy_: number
-    isBeingObserved_: boolean
+    isBeingObserved: boolean
 
     lowestObserverState_: IDerivationState_ // Used to avoid redundant propagations
-    isPendingUnobservation_: boolean // Used to push itself to global.pendingUnobservations at most once per batch.
+    isPendingUnobservation: boolean // Used to push itself to global.pendingUnobservations at most once per batch.
 
     observers_: Set<IDerivation>
 
@@ -91,9 +91,9 @@ export function removeObserver(observable: IObservable, node: IDerivation) {
 }
 
 export function queueForUnobservation(observable: IObservable) {
-    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)
     }
 }
@@ -114,11 +114,11 @@ export function endBatch() {
         const list = globalState.pendingUnobservations
         for (let i = 0; i < list.length; i++) {
             const 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) {
@@ -146,12 +146,12 @@ export function reportObserved(observable: IObservable): boolean {
             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)
     }