mobx 6.16.1 → 7.0.1

package/src/core/atom.ts

@@ -6,8 +6,6 @@ import {
     endBatch,
     getNextId,
     noop,
-    onBecomeObserved,
-    onBecomeUnobserved,
     propagateChanged,
     reportObserved,
     startBatch,
@@ -23,13 +21,17 @@ export interface IAtom extends IObservable {
     reportChanged(): void
 }
 
+const enum AtomFlags {
+    isBeingObserved = 0b001,
+    isPendingUnobservation = 0b010,
+    diffValue = 0b100
+}
+
 export class Atom implements IAtom {
-    private static readonly isBeingObservedMask_ = 0b001
-    private static readonly isPendingUnobservationMask_ = 0b010
-    private static readonly diffValueMask_ = 0b100
     private flags_ = 0b000
 
-    observers_ = new Set<IDerivation>()
+    // Allocated lazily on first observer to save memory.
+    observers_: Set<IDerivation> | null = null
 
     lastAccessedBy_ = 0
     lowestObserverState_ = IDerivationState_.NOT_TRACKING_
@@ -41,24 +43,24 @@ export class Atom implements IAtom {
 
     // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
     get isBeingObserved(): boolean {
-        return getFlag(this.flags_, Atom.isBeingObservedMask_)
+        return getFlag(this.flags_, AtomFlags.isBeingObserved)
     }
     set isBeingObserved(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, Atom.isBeingObservedMask_, newValue)
+        this.flags_ = setFlag(this.flags_, AtomFlags.isBeingObserved, newValue)
     }
 
     get isPendingUnobservation(): boolean {
-        return getFlag(this.flags_, Atom.isPendingUnobservationMask_)
+        return getFlag(this.flags_, AtomFlags.isPendingUnobservation)
     }
     set isPendingUnobservation(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, Atom.isPendingUnobservationMask_, newValue)
+        this.flags_ = setFlag(this.flags_, AtomFlags.isPendingUnobservation, newValue)
     }
 
     get diffValue(): 0 | 1 {
-        return getFlag(this.flags_, Atom.diffValueMask_) ? 1 : 0
+        return getFlag(this.flags_, AtomFlags.diffValue) ? 1 : 0
     }
     set diffValue(newValue: 0 | 1) {
-        this.flags_ = setFlag(this.flags_, Atom.diffValueMask_, newValue === 1 ? true : false)
+        this.flags_ = setFlag(this.flags_, AtomFlags.diffValue, newValue === 1 ? true : false)
     }
 
     // onBecomeObservedListeners
@@ -110,11 +112,11 @@ export function createAtom(
     const atom = new Atom(name)
     // default `noop` listener will not initialize the hook Set
     if (onBecomeObservedHandler !== noop) {
-        onBecomeObserved(atom, onBecomeObservedHandler)
+        atom.onBOL = new Set([onBecomeObservedHandler])
     }
 
     if (onBecomeUnobservedHandler !== noop) {
-        onBecomeUnobserved(atom, onBecomeUnobservedHandler)
+        atom.onBUOL = new Set([onBecomeUnobservedHandler])
     }
     return atom
 }

package/src/core/computedvalue.ts

@@ -5,10 +5,8 @@ import {
     IEqualsComparer,
     IObservable,
     Lambda,
-    TraceMode,
-    autorun,
     clearObserving,
-    comparer,
+    compareDefault,
     createAction,
     createInstanceofPredicate,
     endBatch,
@@ -16,6 +14,7 @@ import {
     globalState,
     isCaughtException,
     isSpyEnabled,
+    markObserved,
     propagateChangeConfirmed,
     propagateMaybeChanged,
     reportObserved,
@@ -24,9 +23,6 @@ import {
     startBatch,
     toPrimitive,
     trackDerivedFunction,
-    untrackedEnd,
-    untrackedStart,
-    UPDATE,
     die,
     allowStateChangesStart,
     allowStateChangesEnd
@@ -77,11 +73,20 @@ export type IComputedDidChange<T = any> = {
  *
  * If at any point it's outside batch and it isn't observed: reset everything and go to 1.
  */
+const enum ComputedValueFlags {
+    isComputing = 0b00001,
+    isRunningSetter = 0b00010,
+    isBeingObserved = 0b00100,
+    isPendingUnobservation = 0b01000,
+    diffValue = 0b10000
+}
+
 export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDerivation {
     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
-    observers_ = new Set<IDerivation>()
+    // Lazily allocated on first observer - see Atom.observers_.
+    observers_: Set<IDerivation> | null = null
     runId_ = 0
     lastAccessedBy_ = 0
     lowestObserverState_ = IDerivationState_.UP_TO_DATE_
@@ -90,16 +95,10 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     name_: string
     triggeredBy_?: string
 
-    private static readonly isComputingMask_ = 0b00001
-    private static readonly isRunningSetterMask_ = 0b00010
-    private static readonly isBeingObservedMask_ = 0b00100
-    private static readonly isPendingUnobservationMask_ = 0b01000
-    private static readonly diffValueMask_ = 0b10000
     private flags_ = 0b00000
 
     derivation: () => T // N.B: unminified as it is used by MST
     setter_?: (value: T) => void
-    isTracing_: TraceMode = TraceMode.NONE
     scope_: Object | undefined
     private equals_: IEqualsComparer<any>
     private requiresReaction_: boolean | undefined
@@ -110,11 +109,9 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
      *
      * The `name` property is for debug purposes only.
      *
-     * The `equals` property specifies the comparer function to use to determine if a newly produced
-     * value differs from the previous value. Two comparers are provided in the library; `defaultComparer`
-     * compares based on identity comparison (===), and `structuralComparer` deeply compares the structure.
-     * Structural comparison can be convenient if you always produce a new aggregated object and
-     * don't want to notify observers if it is structurally the same.
+     * The `equals` property specifies the comparer function used to determine if a newly produced
+     * value differs from the previous value. Structural comparison can be convenient if you always
+     * produce a new aggregated object and don't want to notify observers if it is structurally the same.
      * This is useful for working with vectors, mouse coordinates etc.
      */
     constructor(options: IComputedValueOptions<T>) {
@@ -129,11 +126,7 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
                 options.set
             ) as any
         }
-        this.equals_ =
-            options.equals ||
-            ((options as any).compareStructural || (options as any).struct
-                ? comparer.structural
-                : comparer.default)
+        this.equals_ = options.equals || compareDefault
         this.scope_ = options.context
         this.requiresReaction_ = options.requiresReaction
         this.keepAlive_ = !!options.keepAlive
@@ -160,40 +153,40 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
 
     // to check for cycles
     private get isComputing(): boolean {
-        return getFlag(this.flags_, ComputedValue.isComputingMask_)
+        return getFlag(this.flags_, ComputedValueFlags.isComputing)
     }
     private set isComputing(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, ComputedValue.isComputingMask_, newValue)
+        this.flags_ = setFlag(this.flags_, ComputedValueFlags.isComputing, newValue)
     }
 
     private get isRunningSetter(): boolean {
-        return getFlag(this.flags_, ComputedValue.isRunningSetterMask_)
+        return getFlag(this.flags_, ComputedValueFlags.isRunningSetter)
     }
     private set isRunningSetter(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, ComputedValue.isRunningSetterMask_, newValue)
+        this.flags_ = setFlag(this.flags_, ComputedValueFlags.isRunningSetter, newValue)
     }
 
     get isBeingObserved(): boolean {
-        return getFlag(this.flags_, ComputedValue.isBeingObservedMask_)
+        return getFlag(this.flags_, ComputedValueFlags.isBeingObserved)
     }
     set isBeingObserved(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, ComputedValue.isBeingObservedMask_, newValue)
+        this.flags_ = setFlag(this.flags_, ComputedValueFlags.isBeingObserved, newValue)
     }
 
     get isPendingUnobservation(): boolean {
-        return getFlag(this.flags_, ComputedValue.isPendingUnobservationMask_)
+        return getFlag(this.flags_, ComputedValueFlags.isPendingUnobservation)
     }
     set isPendingUnobservation(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, ComputedValue.isPendingUnobservationMask_, newValue)
+        this.flags_ = setFlag(this.flags_, ComputedValueFlags.isPendingUnobservation, newValue)
     }
 
     get diffValue(): 0 | 1 {
-        return getFlag(this.flags_, ComputedValue.diffValueMask_) ? 1 : 0
+        return getFlag(this.flags_, ComputedValueFlags.diffValue) ? 1 : 0
     }
     set diffValue(newValue: 0 | 1) {
         this.flags_ = setFlag(
             this.flags_,
-            ComputedValue.diffValueMask_,
+            ComputedValueFlags.diffValue,
             newValue === 1 ? true : false
         )
     }
@@ -209,7 +202,7 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
         if (
             globalState.inBatch === 0 &&
             // !globalState.trackingDerivatpion &&
-            this.observers_.size === 0 &&
+            (!this.observers_ || this.observers_.size === 0) &&
             !this.keepAlive_
         ) {
             if (shouldCompute(this)) {
@@ -219,6 +212,7 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
                 endBatch()
             }
         } else {
+            const wasBeingObserved = this.isBeingObserved
             reportObserved(this)
             if (shouldCompute(this)) {
                 let prevTrackingContext = globalState.trackingContext
@@ -229,6 +223,10 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
                     propagateChangeConfirmed(this)
                 }
                 globalState.trackingContext = prevTrackingContext
+            } else if (!wasBeingObserved && this.isBeingObserved) {
+                // We just became observed while serving a cached value, so the getter
+                // won't run and won't re-report our dependencies. Cascade to them. #4547
+                this.observing_.forEach(markObserved)
             }
         }
         const result = this.value_!
@@ -289,7 +287,7 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     computeValue_(track: boolean) {
         this.isComputing = true
         // don't allow state changes during computation
-        const prev = allowStateChangesStart(false)
+        const prev = __DEV__ ? allowStateChangesStart(false) : false
         let res: T | CaughtException
         if (track) {
             res = trackDerivedFunction(this, this.derivation, this.scope_)
@@ -304,7 +302,9 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
                 }
             }
         }
-        allowStateChangesEnd(prev)
+        if (__DEV__) {
+            allowStateChangesEnd(prev)
+        }
         this.isComputing = false
         return res
     }
@@ -313,46 +313,13 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
         if (!this.keepAlive_) {
             clearObserving(this)
             this.value_ = undefined // don't hold on to computed value!
-            if (__DEV__ && this.isTracing_ !== TraceMode.NONE) {
-                console.log(
-                    `[mobx.trace] Computed value '${this.name_}' was suspended and it will recompute on the next access.`
-                )
-            }
         }
     }
 
-    observe_(listener: (change: IComputedDidChange<T>) => void, fireImmediately?: boolean): Lambda {
-        let firstTime = true
-        let prevValue: T | undefined = undefined
-        return autorun(() => {
-            // TODO: why is this in a different place than the spyReport() function? in all other observables it's called in the same place
-            let newValue = this.get()
-            if (!firstTime || fireImmediately) {
-                const prevU = untrackedStart()
-                listener({
-                    observableKind: "computed",
-                    debugObjectName: this.name_,
-                    type: UPDATE,
-                    object: this,
-                    newValue,
-                    oldValue: prevValue
-                })
-                untrackedEnd(prevU)
-            }
-            firstTime = false
-            prevValue = newValue
-        })
-    }
-
     warnAboutUntrackedRead_() {
         if (!__DEV__) {
             return
         }
-        if (this.isTracing_ !== TraceMode.NONE) {
-            console.log(
-                `[mobx.trace] Computed value '${this.name_}' is being read outside a reactive context. Doing a full recompute.`
-            )
-        }
         if (
             typeof this.requiresReaction_ === "boolean"
                 ? this.requiresReaction_

package/src/core/derivation.ts

@@ -8,7 +8,7 @@ import {
     removeObserver
 } from "../internal"
 
-export enum IDerivationState_ {
+export const enum IDerivationState_ {
     // before being run or (outside batch and not being observed)
     // at this point derivation is not holding any data about dependency tree
     NOT_TRACKING_ = -1,
@@ -28,12 +28,6 @@ export enum IDerivationState_ {
     STALE_ = 2
 }
 
-export enum TraceMode {
-    NONE,
-    LOG,
-    BREAK
-}
-
 /**
  * A derivation is everything that can be derived from the state (all the atoms) in a pure manner.
  * See https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74
@@ -52,7 +46,6 @@ export interface IDerivation extends IDepTreeNode {
      */
     unboundDepsCount_: number
     onBecomeStale_(): void
-    isTracing_: TraceMode
 
     /**
      *  warn if the derivation has no dependencies after creation/update
@@ -90,7 +83,7 @@ export function shouldCompute(derivation: IDerivation): boolean {
             return true
         case IDerivationState_.POSSIBLY_STALE_: {
             // state propagation can occur outside of action/reactive context #2195
-            const prevAllowStateReads = allowStateReadsStart(true)
+            const prevAllowStateReads = __DEV__ ? allowStateReadsStart(true) : true
             const prevUntracked = untrackedStart() // no need for those computeds to be reported, they will be picked up in trackDerivedFunction.
             const obs = derivation.observing_,
                 l = obs.length
@@ -105,7 +98,9 @@ export function shouldCompute(derivation: IDerivation): boolean {
                         } catch (e) {
                             // we are not interested in the value *or* exception at this moment, but if there is one, notify all
                             untrackedEnd(prevUntracked)
-                            allowStateReadsEnd(prevAllowStateReads)
+                            if (__DEV__) {
+                                allowStateReadsEnd(prevAllowStateReads)
+                            }
                             return true
                         }
                     }
@@ -114,14 +109,18 @@ export function shouldCompute(derivation: IDerivation): boolean {
                     // invariantShouldCompute(derivation)
                     if ((derivation.dependenciesState_ as any) === IDerivationState_.STALE_) {
                         untrackedEnd(prevUntracked)
-                        allowStateReadsEnd(prevAllowStateReads)
+                        if (__DEV__) {
+                            allowStateReadsEnd(prevAllowStateReads)
+                        }
                         return true
                     }
                 }
             }
             changeDependenciesStateTo0(derivation)
             untrackedEnd(prevUntracked)
-            allowStateReadsEnd(prevAllowStateReads)
+            if (__DEV__) {
+                allowStateReadsEnd(prevAllowStateReads)
+            }
             return false
         }
     }
@@ -135,7 +134,7 @@ export function checkIfStateModificationsAreAllowed(atom: IAtom) {
     if (!__DEV__) {
         return
     }
-    const hasObservers = atom.observers_.size > 0
+    const hasObservers = !!atom.observers_ && atom.observers_.size > 0
     // Should not be possible to change observed state outside strict mode, except during initialization, see #563
     if (
         !globalState.allowStateChanges &&
@@ -165,7 +164,7 @@ export function checkIfStateReadsAreAllowed(observable: IObservable) {
  * as observer of any of the accessed observables.
  */
 export function trackDerivedFunction<T>(derivation: IDerivation, f: () => T, context: any) {
-    const prevAllowStateReads = allowStateReadsStart(true)
+    const prevAllowStateReads = __DEV__ ? allowStateReadsStart(true) : true
     changeDependenciesStateTo0(derivation)
     // Preallocate array; will be trimmed by bindDependencies.
     derivation.newObserving_ = new Array(
@@ -193,7 +192,9 @@ export function trackDerivedFunction<T>(derivation: IDerivation, f: () => T, con
     bindDependencies(derivation)
 
     warnAboutDerivationWithoutDependencies(derivation)
-    allowStateReadsEnd(prevAllowStateReads)
+    if (__DEV__) {
+        allowStateReadsEnd(prevAllowStateReads)
+    }
     return result
 }
 

package/src/core/globalstate.ts

@@ -1,6 +1,8 @@
-import { IDerivation, IObservable, Reaction, die, getGlobal } from "../internal"
+import { IDerivation, IObservable, Reaction, die } from "../internal"
 import { ComputedValue } from "./computedvalue"
 
+const MOBX_GLOBALS_VERSION = 7
+
 /**
  * These values will persist if global state is reset
  */
@@ -14,8 +16,7 @@ const persistentKeys: (keyof MobXGlobals)[] = [
     "allowStateReads",
     "disableErrorBoundaries",
     "runId",
-    "UNCHANGED",
-    "useProxies"
+    "UNCHANGED"
 ]
 
 export type IUNCHANGED = {}
@@ -29,7 +30,7 @@ export class MobXGlobals {
      * N.B: this version is unrelated to the package version of MobX, and is only the version of the
      * internal state storage of MobX, and can be the same across many different package versions
      */
-    version = 6
+    version = MOBX_GLOBALS_VERSION
 
     /**
      * globally unique token to signal unchanged
@@ -81,6 +82,14 @@ export class MobXGlobals {
      */
     isRunningReactions = false
 
+    /**
+     * Are we currently draining pendingUnobservations in endBatch?
+     * An onBecomeUnobserved handler can dispose a Reaction, which calls
+     * startBatch/endBatch again; this guards against re-entering the same
+     * drain loop recursively (see endBatch in observable.ts).
+     */
+    isRunningUnobservations = false
+
     /**
      * Is it allowed to change observables at this point?
      * In general, MobX doesn't allow that when running computations and React.render.
@@ -138,12 +147,6 @@ export class MobXGlobals {
      */
     suppressReactionErrors = false
 
-    useProxies = true
-    /*
-     * print warnings about code that would fail if proxies weren't available
-     */
-    verifyProxies = false
-
     /**
      * False forces all object's descriptors to
      * writable: true
@@ -156,11 +159,11 @@ let canMergeGlobalState = true
 let isolateCalled = false
 
 export let globalState: MobXGlobals = (function () {
-    let global = getGlobal()
+    let global = globalThis as any
     if (global.__mobxInstanceCount > 0 && !global.__mobxGlobals) {
         canMergeGlobalState = false
     }
-    if (global.__mobxGlobals && global.__mobxGlobals.version !== new MobXGlobals().version) {
+    if (global.__mobxGlobals && global.__mobxGlobals.version !== MOBX_GLOBALS_VERSION) {
         canMergeGlobalState = false
     }
 
@@ -195,7 +198,7 @@ export function isolateGlobalState() {
     }
     isolateCalled = true
     if (canMergeGlobalState) {
-        let global = getGlobal()
+        let global = globalThis as any
         if (--global.__mobxInstanceCount === 0) {
             global.__mobxGlobals = undefined
         }