mobx 6.16.1 → 7.0.0

package/src/core/computedvalue.ts

@@ -5,10 +5,8 @@ import {
     IEqualsComparer,
     IObservable,
     Lambda,
-    TraceMode,
-    autorun,
     clearObserving,
-    comparer,
+    compareDefault,
     createAction,
     createInstanceofPredicate,
     endBatch,
@@ -24,9 +22,6 @@ import {
     startBatch,
     toPrimitive,
     trackDerivedFunction,
-    untrackedEnd,
-    untrackedStart,
-    UPDATE,
     die,
     allowStateChangesStart,
     allowStateChangesEnd
@@ -77,6 +72,14 @@ 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
@@ -90,16 +93,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 +107,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 +124,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 +151,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
         )
     }
@@ -289,7 +280,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 +295,9 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
                 }
             }
         }
-        allowStateChangesEnd(prev)
+        if (__DEV__) {
+            allowStateChangesEnd(prev)
+        }
         this.isComputing = false
         return res
     }
@@ -313,46 +306,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
         }
     }
@@ -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
@@ -138,12 +139,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 +151,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 +190,7 @@ export function isolateGlobalState() {
     }
     isolateCalled = true
     if (canMergeGlobalState) {
-        let global = getGlobal()
+        let global = globalThis as any
         if (--global.__mobxInstanceCount === 0) {
             global.__mobxGlobals = undefined
         }

package/src/core/observable.ts

@@ -1,11 +1,8 @@
 import {
     Lambda,
     ComputedValue,
-    IDependencyTree,
     IDerivation,
     IDerivationState_,
-    TraceMode,
-    getDependencyTree,
     globalState,
     runReactions,
     checkIfStateReadsAreAllowed
@@ -192,9 +189,6 @@ export function propagateChanged(observable: IObservable) {
     // Ideally we use for..of here, but the downcompiled version is really slow...
     observable.observers_.forEach(d => {
         if (d.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {
-            if (__DEV__ && d.isTracing_ !== TraceMode.NONE) {
-                logTraceInfo(d, observable)
-            }
             d.onBecomeStale_()
         }
         d.dependenciesState_ = IDerivationState_.STALE_
@@ -213,9 +207,6 @@ export function propagateChangeConfirmed(observable: IObservable) {
     observable.observers_.forEach(d => {
         if (d.dependenciesState_ === IDerivationState_.POSSIBLY_STALE_) {
             d.dependenciesState_ = IDerivationState_.STALE_
-            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.
         ) {
@@ -241,42 +232,3 @@ export function propagateMaybeChanged(observable: IObservable) {
     })
     // invariantLOS(observable, "maybe end");
 }
-
-function logTraceInfo(derivation: IDerivation, observable: IObservable) {
-    console.log(
-        `[mobx.trace] '${derivation.name_}' is invalidated due to a change in: '${observable.name_}'`
-    )
-    if (derivation.isTracing_ === TraceMode.BREAK) {
-        const lines = []
-        printDepTree(getDependencyTree(derivation), lines, 1)
-
-        // prettier-ignore
-        new Function(
-`debugger;
-/*
-Tracing '${derivation.name_}'
-
-You are entering this break point because derivation '${derivation.name_}' is being traced and '${observable.name_}' is now forcing it to update.
-Just follow the stacktrace you should now see in the devtools to see precisely what piece of your code is causing this update
-The stackframe you are looking for is at least ~6-8 stack-frames up.
-
-${derivation instanceof ComputedValue ? derivation.derivation.toString().replace(/[*]\//g, "/") : ""}
-
-The dependencies for this derivation are:
-
-${lines.join("\n")}
-*/
-    `)()
-    }
-}
-
-function printDepTree(tree: IDependencyTree, lines: string[], depth: number) {
-    if (lines.length >= 1000) {
-        lines.push("(and many more)")
-        return
-    }
-    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

@@ -4,7 +4,6 @@ import {
     IDerivationState_,
     IObservable,
     Lambda,
-    TraceMode,
     clearObserving,
     createInstanceofPredicate,
     endBatch,
@@ -17,7 +16,6 @@ import {
     spyReportEnd,
     spyReportStart,
     startBatch,
-    trace,
     trackDerivedFunction,
     GenericAbortSignal
 } from "../internal"
@@ -45,7 +43,6 @@ import { getFlag, setFlag } from "../utils/utils"
 
 export interface IReactionPublic {
     dispose(): void
-    trace(enterBreakPoint?: boolean): void
 }
 
 export interface IReactionDisposer {
@@ -53,6 +50,14 @@ export interface IReactionDisposer {
     [$mobx]: Reaction
 }
 
+const enum ReactionFlags {
+    isDisposed = 0b00001,
+    isScheduled = 0b00010,
+    isTrackPending = 0b00100,
+    isRunning = 0b01000,
+    diffValue = 0b10000
+}
+
 export class Reaction implements IDerivation, IReactionPublic {
     observing_: IObservable[] = [] // nodes we are looking at. Our value depends on these nodes
     newObserving_: IObservable[] = []
@@ -60,15 +65,8 @@ export class Reaction implements IDerivation, IReactionPublic {
     runId_ = 0
     unboundDepsCount_ = 0
 
-    private static readonly isDisposedMask_ = 0b00001
-    private static readonly isScheduledMask_ = 0b00010
-    private static readonly isTrackPendingMask_ = 0b00100
-    private static readonly isRunningMask_ = 0b01000
-    private static readonly diffValueMask_ = 0b10000
     private flags_ = 0b00000
 
-    isTracing_: TraceMode = TraceMode.NONE
-
     constructor(
         public name_: string = __DEV__ ? "Reaction@" + getNextId() : "Reaction",
         private onInvalidate_: () => void,
@@ -77,38 +75,38 @@ export class Reaction implements IDerivation, IReactionPublic {
     ) {}
 
     get isDisposed() {
-        return getFlag(this.flags_, Reaction.isDisposedMask_)
+        return getFlag(this.flags_, ReactionFlags.isDisposed)
     }
     set isDisposed(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, Reaction.isDisposedMask_, newValue)
+        this.flags_ = setFlag(this.flags_, ReactionFlags.isDisposed, newValue)
     }
 
     get isScheduled() {
-        return getFlag(this.flags_, Reaction.isScheduledMask_)
+        return getFlag(this.flags_, ReactionFlags.isScheduled)
     }
     set isScheduled(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, Reaction.isScheduledMask_, newValue)
+        this.flags_ = setFlag(this.flags_, ReactionFlags.isScheduled, newValue)
     }
 
     get isTrackPending() {
-        return getFlag(this.flags_, Reaction.isTrackPendingMask_)
+        return getFlag(this.flags_, ReactionFlags.isTrackPending)
     }
     set isTrackPending(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, Reaction.isTrackPendingMask_, newValue)
+        this.flags_ = setFlag(this.flags_, ReactionFlags.isTrackPending, newValue)
     }
 
     get isRunning() {
-        return getFlag(this.flags_, Reaction.isRunningMask_)
+        return getFlag(this.flags_, ReactionFlags.isRunning)
     }
     set isRunning(newValue: boolean) {
-        this.flags_ = setFlag(this.flags_, Reaction.isRunningMask_, newValue)
+        this.flags_ = setFlag(this.flags_, ReactionFlags.isRunning, newValue)
     }
 
     get diffValue(): 0 | 1 {
-        return getFlag(this.flags_, Reaction.diffValueMask_) ? 1 : 0
+        return getFlag(this.flags_, ReactionFlags.diffValue) ? 1 : 0
     }
     set diffValue(newValue: 0 | 1) {
-        this.flags_ = setFlag(this.flags_, Reaction.diffValueMask_, newValue === 1 ? true : false)
+        this.flags_ = setFlag(this.flags_, ReactionFlags.diffValue, newValue === 1 ? true : false)
     }
 
     onBecomeStale_() {
@@ -159,7 +157,7 @@ export class Reaction implements IDerivation, IReactionPublic {
             // console.warn("Reaction already disposed") // Note: Not a warning / error in mobx 4 either
         }
         startBatch()
-        const notify = isSpyEnabled()
+        const notify = __DEV__ && isSpyEnabled()
         let startTime
         if (__DEV__ && notify) {
             startTime = Date.now()
@@ -250,10 +248,6 @@ export class Reaction implements IDerivation, IReactionPublic {
     toString() {
         return `Reaction[${this.name_}]`
     }
-
-    trace(enterBreakPoint: boolean = false) {
-        trace(this, enterBreakPoint)
-    }
 }
 
 export function onReactionError(handler: (error: any, derivation: IDerivation) => void): Lambda {

package/src/core/spy.ts

@@ -2,7 +2,7 @@ import { IComputedDidChange } from "./computedvalue"
 import { IValueDidChange, IBoxDidChange } from "./../types/observablevalue"
 import { IObjectDidChange } from "./../types/observableobject"
 import { IArrayDidChange } from "./../types/observablearray"
-import { Lambda, globalState, once, ISetDidChange, IMapDidChange } from "../internal"
+import { Lambda, globalState, once, ISetDidChange, IMapDidChange, assign } from "../internal"
 
 export function isSpyEnabled() {
     return __DEV__ && !!globalState.spyListeners.length
@@ -41,7 +41,7 @@ export function spyReportStart(event: PureSpyEvent) {
     if (!__DEV__) {
         return
     }
-    const change = { ...event, spyReportStart: true as const }
+    const change = assign({}, event, { spyReportStart: true as const })
     spyReport(change)
 }
 
@@ -52,7 +52,7 @@ export function spyReportEnd(change?: { time?: number }) {
         return
     }
     if (change) {
-        spyReport({ ...change, type: "report-end", spyReportEnd: true })
+        spyReport(assign({}, change, { type: "report-end" as const, spyReportEnd: true as const }))
     } else {
         spyReport(END_EVENT)
     }

package/src/errors.ts

@@ -1,4 +1,4 @@
-const niceErrors = {
+export const niceErrors = {
     0: `Invalid value for configuration 'enforceActions', expected 'never', 'always' or 'observed'`,
     1(annotationType, key: PropertyKey) {
         return `Cannot apply '${annotationType}' to '${key.toString()}': Field not found.`
@@ -26,10 +26,6 @@ const niceErrors = {
     14: "Intercept handlers should return nothing or a change object",
     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}`
-    },
-    18: "mobx.map requires Map polyfill for the current browser. Check babel-polyfill or core-js/es6/map.js",
     19(other) {
         return "Cannot initialize from classes that inherit from Map: " + other.constructor.name
     },
@@ -39,7 +35,6 @@ const niceErrors = {
     21(dataStructure) {
         return `Cannot convert to map from '${dataStructure}'`
     },
-    22: "mobx.set requires Set polyfill for the current browser. Check babel-polyfill or core-js/es6/set.js",
     23: "It is not possible to get index atoms from arrays",
     24(thing) {
         return "Cannot obtain administration from " + thing
@@ -72,7 +67,25 @@ const niceErrors = {
         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"
+    39: "'defineProperty()' can only be used on observable objects",
+    40(length) {
+        return "Out of range: " + length
+    },
+    41(other) {
+        return "Cannot initialize set from " + other
+    },
+    42(key) {
+        return `Invalid index: '${key}'`
+    },
+    43(annotationType, name, kind) {
+        return (
+            `Cannot apply '${annotationType}' to '${name}' (kind: ${kind}):` +
+            `\n'${annotationType}' can only be used on properties with a function value.`
+        )
+    },
+    44(annotationType) {
+        return `'${annotationType}' can only be used with 'makeObservable'`
+    }
 } as const
 
 const errors: typeof niceErrors = __DEV__ ? niceErrors : ({} as any)
@@ -84,10 +97,8 @@ export function die(error: string | keyof typeof errors, ...args: any[]): never
         throw new Error(`[MobX] ${e}`)
     }
     throw new Error(
-        typeof error === "number"
-            ? `[MobX] minified error nr: ${error}${
-                  args.length ? " " + args.map(String).join(",") : ""
-              }. Find the full error at: https://github.com/mobxjs/mobx/blob/main/packages/mobx/src/errors.ts`
-            : `[MobX] ${error}`
+        `[MobX] minified error nr: ${error}${
+            args.length ? " " + args.map(String).join(",") : ""
+        }. See mobx.js.org/errors`
     )
 }

package/src/internal.ts

@@ -5,8 +5,7 @@ it will cause undefined errors (for example because super classes or local varia
 With this file that will still happen,
 but at least in this file we can magically reorder the imports with trial and error until the build succeeds again.
 */
-export * from "./utils/global"
-export * from "./errors"
+export { die } from "./errors"
 export * from "./utils/utils"
 export * from "./api/decorators"
 export * from "./core/atom"
@@ -43,7 +42,6 @@ export * from "./api/isobservable"
 export * from "./api/object-api"
 export * from "./api/observe"
 export * from "./api/tojs"
-export * from "./api/trace"
 export * from "./api/transaction"
 export * from "./api/when"
 export * from "./types/dynamicobject"
@@ -54,7 +52,6 @@ export * from "./types/observablearray"
 export * from "./types/observablemap"
 export * from "./types/observableset"
 export * from "./types/observableobject"
-export * from "./types/legacyobservablearray"
 export * from "./types/type-utils"
 export * from "./utils/eq"
 export * from "./utils/iterable"