mobx 6.1.8 → 6.9.0

package/src/core/action.ts

@@ -14,7 +14,8 @@ import {
     ACTION,
     EMPTY_ARRAY,
     die,
-    getDescriptor
+    getDescriptor,
+    defineProperty
 } from "../internal"
 
 // we don't use globalState for these in order to avoid possible issues with multiple
@@ -38,9 +39,12 @@ export function createAction(
     ref?: Object
 ): Function {
     if (__DEV__) {
-        if (!isFunction(fn)) die("`action` can only be invoked on functions")
-        if (typeof actionName !== "string" || !actionName)
+        if (!isFunction(fn)) {
+            die("`action` can only be invoked on functions")
+        }
+        if (typeof actionName !== "string" || !actionName) {
             die(`actions should have valid names, got: '${actionName}'`)
+        }
     }
     function res() {
         return executeAction(actionName, autoAction, fn, ref || this, arguments)
@@ -48,7 +52,7 @@ export function createAction(
     res.isMobxAction = true
     if (isFunctionNameConfigurable) {
         tmpNameDescriptor.value = actionName
-        Object.defineProperty(res, "name", tmpNameDescriptor)
+        defineProperty(res, "name", tmpNameDescriptor)
     }
     return res
 }
@@ -136,7 +140,9 @@ export function _endAction(runInfo: IActionRunInfo) {
     allowStateChangesEnd(runInfo.prevAllowStateChanges_)
     allowStateReadsEnd(runInfo.prevAllowStateReads_)
     endBatch()
-    if (runInfo.runAsAction_) untrackedEnd(runInfo.prevDerivation_)
+    if (runInfo.runAsAction_) {
+        untrackedEnd(runInfo.prevDerivation_)
+    }
     if (__DEV__ && runInfo.notifySpy_) {
         spyReportEnd({ time: Date.now() - runInfo.startTime_ })
     }

package/src/core/atom.ts

@@ -11,13 +11,14 @@ import {
     propagateChanged,
     reportObserved,
     startBatch,
-    Lambda
+    Lambda,
+    globalState
 } from "../internal"
 
 export const $mobx = Symbol("mobx administration")
 
 export interface IAtom extends IObservable {
-    reportObserved()
+    reportObserved(): boolean
     reportChanged()
 }
 
@@ -66,6 +67,12 @@ export class Atom implements IAtom {
     public reportChanged() {
         startBatch()
         propagateChanged(this)
+        // We could update state version only at the end of batch,
+        // but we would still have to switch some global flag here to signal a change.
+        globalState.stateVersion =
+            globalState.stateVersion < Number.MAX_SAFE_INTEGER
+                ? globalState.stateVersion + 1
+                : Number.MIN_SAFE_INTEGER
         endBatch()
     }
 

package/src/core/computedvalue.ts

@@ -35,7 +35,6 @@ import {
 export interface IComputedValue<T> {
     get(): T
     set(value: T): void
-    observe_(listener: (change: IComputedDidChange<T>) => void, fireImmediately?: boolean): Lambda
 }
 
 export interface IComputedValueOptions<T> {
@@ -98,7 +97,7 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     isTracing_: TraceMode = TraceMode.NONE
     scope_: Object | undefined
     private equals_: IEqualsComparer<any>
-    private requiresReaction_: boolean
+    private requiresReaction_: boolean | undefined
     keepAlive_: boolean
 
     /**
@@ -114,7 +113,9 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
      * This is useful for working with vectors, mouse coordinates etc.
      */
     constructor(options: IComputedValueOptions<T>) {
-        if (!options.get) die(31)
+        if (!options.get) {
+            die(31)
+        }
         this.derivation = options.get!
         this.name_ = options.name || (__DEV__ ? "ComputedValue@" + getNextId() : "ComputedValue")
         if (options.set) {
@@ -129,7 +130,7 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
                 ? comparer.structural
                 : comparer.default)
         this.scope_ = options.context
-        this.requiresReaction_ = !!options.requiresReaction
+        this.requiresReaction_ = options.requiresReaction
         this.keepAlive_ = !!options.keepAlive
     }
 
@@ -157,7 +158,9 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
      * Will evaluate its computation first if needed.
      */
     public get(): T {
-        if (this.isComputing_) die(32, this.name_, this.derivation)
+        if (this.isComputing_) {
+            die(32, this.name_, this.derivation)
+        }
         if (
             globalState.inBatch === 0 &&
             // !globalState.trackingDerivatpion &&
@@ -174,27 +177,37 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
             reportObserved(this)
             if (shouldCompute(this)) {
                 let prevTrackingContext = globalState.trackingContext
-                if (this.keepAlive_ && !prevTrackingContext) globalState.trackingContext = this
-                if (this.trackAndCompute()) propagateChangeConfirmed(this)
+                if (this.keepAlive_ && !prevTrackingContext) {
+                    globalState.trackingContext = this
+                }
+                if (this.trackAndCompute()) {
+                    propagateChangeConfirmed(this)
+                }
                 globalState.trackingContext = prevTrackingContext
             }
         }
         const result = this.value_!
 
-        if (isCaughtException(result)) throw result.cause
+        if (isCaughtException(result)) {
+            throw result.cause
+        }
         return result
     }
 
     public set(value: T) {
         if (this.setter_) {
-            if (this.isRunningSetter_) die(33, this.name_)
+            if (this.isRunningSetter_) {
+                die(33, this.name_)
+            }
             this.isRunningSetter_ = true
             try {
                 this.setter_.call(this.scope_, value)
             } finally {
                 this.isRunningSetter_ = false
             }
-        } else die(34, this.name_)
+        } else {
+            die(34, this.name_)
+        }
     }
 
     trackAndCompute(): boolean {
@@ -204,17 +217,6 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
             /* see #1208 */ this.dependenciesState_ === IDerivationState_.NOT_TRACKING_
         const newValue = this.computeValue_(true)
 
-        if (__DEV__ && isSpyEnabled()) {
-            spyReport({
-                observableKind: "computed",
-                debugObjectName: this.name_,
-                object: this.scope_,
-                type: "update",
-                oldValue: this.value_,
-                newValue
-            } as IComputedDidChange)
-        }
-
         const changed =
             wasSuspended ||
             isCaughtException(oldValue) ||
@@ -223,6 +225,17 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
 
         if (changed) {
             this.value_ = newValue
+
+            if (__DEV__ && isSpyEnabled()) {
+                spyReport({
+                    observableKind: "computed",
+                    debugObjectName: this.name_,
+                    object: this.scope_,
+                    type: "update",
+                    oldValue,
+                    newValue
+                } as IComputedDidChange)
+            }
         }
 
         return changed
@@ -255,6 +268,11 @@ 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.`
+                )
+            }
         }
     }
 
@@ -282,18 +300,21 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     }
 
     warnAboutUntrackedRead_() {
-        if (!__DEV__) return
-        if (this.requiresReaction_ === true) {
-            die(`[mobx] Computed value ${this.name_} is read outside a reactive context`)
+        if (!__DEV__) {
+            return
         }
         if (this.isTracing_ !== TraceMode.NONE) {
             console.log(
-                `[mobx.trace] '${this.name_}' is being read outside a reactive context. Doing a full recompute`
+                `[mobx.trace] Computed value '${this.name_}' is being read outside a reactive context. Doing a full recompute.`
             )
         }
-        if (globalState.computedRequiresReaction) {
+        if (
+            typeof this.requiresReaction_ === "boolean"
+                ? this.requiresReaction_
+                : globalState.computedRequiresReaction
+        ) {
             console.warn(
-                `[mobx] Computed value ${this.name_} is being read outside a reactive context. Doing a full recompute`
+                `[mobx] Computed value '${this.name_}' is being read outside a reactive context. Doing a full recompute.`
             )
         }
     }

package/src/core/derivation.ts

@@ -137,7 +137,10 @@ export function checkIfStateModificationsAreAllowed(atom: IAtom) {
     }
     const hasObservers = atom.observers_.size > 0
     // Should not be possible to change observed state outside strict mode, except during initialization, see #563
-    if (!globalState.allowStateChanges && (hasObservers || globalState.enforceActions === "always"))
+    if (
+        !globalState.allowStateChanges &&
+        (hasObservers || globalState.enforceActions === "always")
+    ) {
         console.warn(
             "[MobX] " +
                 (globalState.enforceActions
@@ -145,11 +148,14 @@ export function checkIfStateModificationsAreAllowed(atom: IAtom) {
                     : "Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, a computed value or the render function of a React component? You can wrap side effects in 'runInAction' (or decorate functions with 'action') if needed. Tried to modify: ") +
                 atom.name_
         )
+    }
 }
 
 export function checkIfStateReadsAreAllowed(observable: IObservable) {
     if (__DEV__ && !globalState.allowStateReads && globalState.observableRequiresReaction) {
-        console.warn(`[mobx] Observable ${observable.name_} being read outside a reactive context`)
+        console.warn(
+            `[mobx] Observable '${observable.name_}' being read outside a reactive context.`
+        )
     }
 }
 
@@ -189,13 +195,21 @@ export function trackDerivedFunction<T>(derivation: IDerivation, f: () => T, con
 }
 
 function warnAboutDerivationWithoutDependencies(derivation: IDerivation) {
-    if (!__DEV__) return
+    if (!__DEV__) {
+        return
+    }
 
-    if (derivation.observing_.length !== 0) return
+    if (derivation.observing_.length !== 0) {
+        return
+    }
 
-    if (globalState.reactionRequiresObservable || derivation.requiresObservable_) {
+    if (
+        typeof derivation.requiresObservable_ === "boolean"
+            ? derivation.requiresObservable_
+            : globalState.reactionRequiresObservable
+    ) {
         console.warn(
-            `[mobx] Derivation ${derivation.name_} is created/updated without reading any observable value`
+            `[mobx] Derivation '${derivation.name_}' is created/updated without reading any observable value.`
         )
     }
 }
@@ -220,14 +234,16 @@ function bindDependencies(derivation: IDerivation) {
         const dep = observing[i]
         if (dep.diffValue_ === 0) {
             dep.diffValue_ = 1
-            if (i0 !== i) observing[i0] = dep
+            if (i0 !== i) {
+                observing[i0] = dep
+            }
             i0++
         }
 
         // Upcast is 'safe' here, because if dep is IObservable, `dependenciesState` will be undefined,
         // not hitting the condition
-        if (((dep as any) as IDerivation).dependenciesState_ > lowestNewObservingDerivationState) {
-            lowestNewObservingDerivationState = ((dep as any) as IDerivation).dependenciesState_
+        if ((dep as any as IDerivation).dependenciesState_ > lowestNewObservingDerivationState) {
+            lowestNewObservingDerivationState = (dep as any as IDerivation).dependenciesState_
         }
     }
     observing.length = i0
@@ -270,7 +286,9 @@ export function clearObserving(derivation: IDerivation) {
     const obs = derivation.observing_
     derivation.observing_ = []
     let i = obs.length
-    while (i--) removeObserver(obs[i], derivation)
+    while (i--) {
+        removeObserver(obs[i], derivation)
+    }
 
     derivation.dependenciesState_ = IDerivationState_.NOT_TRACKING_
 }
@@ -309,10 +327,14 @@ export function allowStateReadsEnd(prev: boolean) {
  *
  */
 export function changeDependenciesStateTo0(derivation: IDerivation) {
-    if (derivation.dependenciesState_ === IDerivationState_.UP_TO_DATE_) return
+    if (derivation.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {
+        return
+    }
     derivation.dependenciesState_ = IDerivationState_.UP_TO_DATE_
 
     const obs = derivation.observing_
     let i = obs.length
-    while (i--) obs[i].lowestObserverState_ = IDerivationState_.UP_TO_DATE_
+    while (i--) {
+        obs[i].lowestObserverState_ = IDerivationState_.UP_TO_DATE_
+    }
 }

package/src/core/globalstate.ts

@@ -150,6 +150,11 @@ export class MobXGlobals {
      * configurable: true
      */
     safeDescriptors = true
+
+    /**
+     * Changes with each state update, used by useSyncExternalStore
+     */
+    stateVersion = Number.MIN_SAFE_INTEGER
 }
 
 let canMergeGlobalState = true
@@ -157,11 +162,16 @@ let isolateCalled = false
 
 export let globalState: MobXGlobals = (function () {
     let global = getGlobal()
-    if (global.__mobxInstanceCount > 0 && !global.__mobxGlobals) canMergeGlobalState = false
-    if (global.__mobxGlobals && global.__mobxGlobals.version !== new MobXGlobals().version)
+    if (global.__mobxInstanceCount > 0 && !global.__mobxGlobals) {
+        canMergeGlobalState = false
+    }
+    if (global.__mobxGlobals && global.__mobxGlobals.version !== new MobXGlobals().version) {
         canMergeGlobalState = false
+    }
 
     if (!canMergeGlobalState) {
+        // Because this is a IIFE we need to let isolateCalled a chance to change
+        // so we run it after the event loop completed at least 1 iteration
         setTimeout(() => {
             if (!isolateCalled) {
                 die(35)
@@ -170,7 +180,9 @@ export let globalState: MobXGlobals = (function () {
         return new MobXGlobals()
     } else if (global.__mobxGlobals) {
         global.__mobxInstanceCount += 1
-        if (!global.__mobxGlobals.UNCHANGED) global.__mobxGlobals.UNCHANGED = {} // make merge backward compatible
+        if (!global.__mobxGlobals.UNCHANGED) {
+            global.__mobxGlobals.UNCHANGED = {}
+        } // make merge backward compatible
         return global.__mobxGlobals
     } else {
         global.__mobxInstanceCount = 1
@@ -183,12 +195,15 @@ export function isolateGlobalState() {
         globalState.pendingReactions.length ||
         globalState.inBatch ||
         globalState.isRunningReactions
-    )
+    ) {
         die(36)
+    }
     isolateCalled = true
     if (canMergeGlobalState) {
         let global = getGlobal()
-        if (--global.__mobxInstanceCount === 0) global.__mobxGlobals = undefined
+        if (--global.__mobxInstanceCount === 0) {
+            global.__mobxGlobals = undefined
+        }
         globalState = new MobXGlobals()
     }
 }
@@ -203,7 +218,10 @@ export function getGlobalState(): any {
  */
 export function resetGlobalState() {
     const defaultGlobals = new MobXGlobals()
-    for (let key in defaultGlobals)
-        if (persistentKeys.indexOf(key as any) === -1) globalState[key] = defaultGlobals[key]
+    for (let key in defaultGlobals) {
+        if (persistentKeys.indexOf(key as any) === -1) {
+            globalState[key] = defaultGlobals[key]
+        }
+    }
     globalState.allowStateChanges = !globalState.enforceActions
 }

package/src/core/observable.ts

@@ -69,8 +69,9 @@ export function addObserver(observable: IObservable, node: IDerivation) {
     // invariantObservers(observable);
 
     observable.observers_.add(node)
-    if (observable.lowestObserverState_ > node.dependenciesState_)
+    if (observable.lowestObserverState_ > node.dependenciesState_) {
         observable.lowestObserverState_ = node.dependenciesState_
+    }
 
     // invariantObservers(observable);
     // invariant(observable._observers.indexOf(node) !== -1, "INTERNAL ERROR didn't add node");
@@ -150,7 +151,7 @@ export function reportObserved(observable: IObservable): boolean {
                 observable.onBO()
             }
         }
-        return true
+        return observable.isBeingObserved_
     } else if (observable.observers_.size === 0 && globalState.inBatch > 0) {
         queueForUnobservation(observable)
     }
@@ -183,7 +184,9 @@ export function reportObserved(observable: IObservable): boolean {
 // Called by Atom when its value changes
 export function propagateChanged(observable: IObservable) {
     // invariantLOS(observable, "changed start");
-    if (observable.lowestObserverState_ === IDerivationState_.STALE_) return
+    if (observable.lowestObserverState_ === IDerivationState_.STALE_) {
+        return
+    }
     observable.lowestObserverState_ = IDerivationState_.STALE_
 
     // Ideally we use for..of here, but the downcompiled version is really slow...
@@ -202,16 +205,22 @@ export function propagateChanged(observable: IObservable) {
 // Called by ComputedValue when it recalculate and its value changed
 export function propagateChangeConfirmed(observable: IObservable) {
     // invariantLOS(observable, "confirmed start");
-    if (observable.lowestObserverState_ === IDerivationState_.STALE_) return
+    if (observable.lowestObserverState_ === IDerivationState_.STALE_) {
+        return
+    }
     observable.lowestObserverState_ = IDerivationState_.STALE_
 
     observable.observers_.forEach(d => {
-        if (d.dependenciesState_ === IDerivationState_.POSSIBLY_STALE_)
+        if (d.dependenciesState_ === IDerivationState_.POSSIBLY_STALE_) {
             d.dependenciesState_ = IDerivationState_.STALE_
-        else if (
+            if (__DEV__ && d.isTracing_ !== TraceMode.NONE) {
+                logTraceInfo(d, observable)
+            }
+        } else if (
             d.dependenciesState_ === IDerivationState_.UP_TO_DATE_ // this happens during computing of `d`, just keep lowestObserverState up to date.
-        )
+        ) {
             observable.lowestObserverState_ = IDerivationState_.UP_TO_DATE_
+        }
     })
     // invariantLOS(observable, "confirmed end");
 }
@@ -219,15 +228,14 @@ export function propagateChangeConfirmed(observable: IObservable) {
 // Used by computed when its dependency changed, but we don't wan't to immediately recompute.
 export function propagateMaybeChanged(observable: IObservable) {
     // invariantLOS(observable, "maybe start");
-    if (observable.lowestObserverState_ !== IDerivationState_.UP_TO_DATE_) return
+    if (observable.lowestObserverState_ !== IDerivationState_.UP_TO_DATE_) {
+        return
+    }
     observable.lowestObserverState_ = IDerivationState_.POSSIBLY_STALE_
 
     observable.observers_.forEach(d => {
         if (d.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {
             d.dependenciesState_ = IDerivationState_.POSSIBLY_STALE_
-            if (__DEV__ && d.isTracing_ !== TraceMode.NONE) {
-                logTraceInfo(d, observable)
-            }
             d.onBecomeStale_()
         }
     })
@@ -267,6 +275,8 @@ function printDepTree(tree: IDependencyTree, lines: string[], depth: number) {
         lines.push("(and many more)")
         return
     }
-    lines.push(`${new Array(depth).join("\t")}${tree.name}`) // MWE: not the fastest, but the easiest way :)
-    if (tree.dependencies) tree.dependencies.forEach(child => printDepTree(child, lines, depth + 1))
+    lines.push(`${"\t".repeat(depth - 1)}${tree.name}`)
+    if (tree.dependencies) {
+        tree.dependencies.forEach(child => printDepTree(child, lines, depth + 1))
+    }
 }

package/src/core/reaction.ts

@@ -67,7 +67,7 @@ export class Reaction implements IDerivation, IReactionPublic {
         public name_: string = __DEV__ ? "Reaction@" + getNextId() : "Reaction",
         private onInvalidate_: () => void,
         private errorHandler_?: (error: any, derivation: IDerivation) => void,
-        public requiresObservable_ = false
+        public requiresObservable_?
     ) {}
 
     onBecomeStale_() {
@@ -142,7 +142,9 @@ export class Reaction implements IDerivation, IReactionPublic {
             // disposed during last run. Clean up everything that was bound after the dispose call.
             clearObserving(this)
         }
-        if (isCaughtException(result)) this.reportExceptionInDerivation_(result.cause)
+        if (isCaughtException(result)) {
+            this.reportExceptionInDerivation_(result.cause)
+        }
         if (__DEV__ && notify) {
             spyReportEnd({
                 time: Date.now() - startTime
@@ -157,7 +159,9 @@ export class Reaction implements IDerivation, IReactionPublic {
             return
         }
 
-        if (globalState.disableErrorBoundaries) throw error
+        if (globalState.disableErrorBoundaries) {
+            throw error
+        }
 
         const message = __DEV__
             ? `[mobx] Encountered an uncaught exception that was thrown by a reaction or observer component, in: '${this}'`
@@ -165,7 +169,7 @@ export class Reaction implements IDerivation, IReactionPublic {
         if (!globalState.suppressReactionErrors) {
             console.error(message, error)
             /** If debugging brought you here, please, read the above message :-). Tnx! */
-        } else if (__DEV__) console.warn(`[mobx] (error in reaction '${this.name_}' suppressed, fix error of causing action below)`) // prettier-ignore
+        } else if (__DEV__) { console.warn(`[mobx] (error in reaction '${this.name_}' suppressed, fix error of causing action below)`) } // prettier-ignore
 
         if (__DEV__ && isSpyEnabled()) {
             spyReport({
@@ -210,7 +214,9 @@ export function onReactionError(handler: (error: any, derivation: IDerivation) =
     globalState.globalReactionErrorHandlers.push(handler)
     return () => {
         const idx = globalState.globalReactionErrorHandlers.indexOf(handler)
-        if (idx >= 0) globalState.globalReactionErrorHandlers.splice(idx, 1)
+        if (idx >= 0) {
+            globalState.globalReactionErrorHandlers.splice(idx, 1)
+        }
     }
 }
 
@@ -225,7 +231,9 @@ let reactionScheduler: (fn: () => void) => void = f => f()
 
 export function runReactions() {
     // Trampolining, if runReactions are already running, new reactions will be picked up
-    if (globalState.inBatch > 0 || globalState.isRunningReactions) return
+    if (globalState.inBatch > 0 || globalState.isRunningReactions) {
+        return
+    }
     reactionScheduler(runReactionsHelper)
 }
 
@@ -248,8 +256,9 @@ function runReactionsHelper() {
             allReactions.splice(0) // clear reactions
         }
         let remainingReactions = allReactions.splice(0)
-        for (let i = 0, l = remainingReactions.length; i < l; i++)
+        for (let i = 0, l = remainingReactions.length; i < l; i++) {
             remainingReactions[i].runReaction_()
+        }
     }
     globalState.isRunningReactions = false
 }

package/src/core/spy.ts

@@ -25,14 +25,22 @@ export type PureSpyEvent =
 type SpyEvent = PureSpyEvent & { spyReportStart?: true }
 
 export function spyReport(event: SpyEvent) {
-    if (!__DEV__) return // dead code elimination can do the rest
-    if (!globalState.spyListeners.length) return
+    if (!__DEV__) {
+        return
+    } // dead code elimination can do the rest
+    if (!globalState.spyListeners.length) {
+        return
+    }
     const listeners = globalState.spyListeners
-    for (let i = 0, l = listeners.length; i < l; i++) listeners[i](event)
+    for (let i = 0, l = listeners.length; i < l; i++) {
+        listeners[i](event)
+    }
 }
 
 export function spyReportStart(event: PureSpyEvent) {
-    if (!__DEV__) return
+    if (!__DEV__) {
+        return
+    }
     const change = { ...event, spyReportStart: true as const }
     spyReport(change)
 }
@@ -40,9 +48,14 @@ export function spyReportStart(event: PureSpyEvent) {
 const END_EVENT: SpyEvent = { type: "report-end", spyReportEnd: true }
 
 export function spyReportEnd(change?: { time?: number }) {
-    if (!__DEV__) return
-    if (change) spyReport({ ...change, type: "report-end", spyReportEnd: true })
-    else spyReport(END_EVENT)
+    if (!__DEV__) {
+        return
+    }
+    if (change) {
+        spyReport({ ...change, type: "report-end", spyReportEnd: true })
+    } else {
+        spyReport(END_EVENT)
+    }
 }
 
 export function spy(listener: (change: SpyEvent) => void): Lambda {

package/src/errors.ts

@@ -3,6 +3,17 @@ const niceErrors = {
     1(annotationType, key: PropertyKey) {
         return `Cannot apply '${annotationType}' to '${key.toString()}': Field not found.`
     },
+    /*
+    2(prop) {
+        return `invalid decorator for '${prop.toString()}'`
+    },
+    3(prop) {
+        return `Cannot decorate '${prop.toString()}': action can only be used on properties with a function value.`
+    },
+    4(prop) {
+        return `Cannot decorate '${prop.toString()}': computed can only be used on getter properties.`
+    },
+    */
     5: "'keys()' can only be used on observable objects, arrays, sets and maps",
     6: "'values()' can only be used on observable objects, arrays, sets and maps",
     7: "'entries()' can only be used on observable objects, arrays and maps",
@@ -11,9 +22,9 @@ const niceErrors = {
     10: "'has()' can only be used on observable objects, arrays and maps",
     11: "'get()' can only be used on observable objects, arrays and maps",
     12: `Invalid annotation`,
-    13: `Dynamic observable objects cannot be frozen`,
+    13: `Dynamic observable objects cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)`,
     14: "Intercept handlers should return nothing or a change object",
-    15: `Observable arrays cannot be frozen`,
+    15: `Observable arrays cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)`,
     16: `Modification exception: the internal structure of an observable array was changed.`,
     17(index, length) {
         return `[mobx.array] Index out of bounds, ${index} is larger than ${length}`
@@ -59,7 +70,9 @@ const niceErrors = {
     36: "isolateGlobalState should be called before MobX is running any reactions",
     37(method) {
         return `[mobx] \`observableArray.${method}()\` mutates the array in-place, which is not allowed inside a derivation. Use \`array.slice().${method}()\` instead`
-    }
+    },
+    38: "'ownKeys()' can only be used on observable objects",
+    39: "'defineProperty()' can only be used on observable objects"
 } as const
 
 const errors: typeof niceErrors = __DEV__ ? niceErrors : ({} as any)

package/src/internal.ts

@@ -17,6 +17,7 @@ export * from "./types/actionannotation"
 export * from "./types/flowannotation"
 export * from "./types/computedannotation"
 export * from "./types/observableannotation"
+export * from "./types/autoannotation"
 export * from "./api/observable"
 export * from "./api/computed"
 export * from "./core/action"