mobx 6.16.1 → 7.0.1

package/src/core/observable.ts

@@ -1,11 +1,8 @@
 import {
     Lambda,
     ComputedValue,
-    IDependencyTree,
     IDerivation,
     IDerivationState_,
-    TraceMode,
-    getDependencyTree,
     globalState,
     runReactions,
     checkIfStateReadsAreAllowed
@@ -29,7 +26,7 @@ export interface IObservable extends IDepTreeNode {
     lowestObserverState_: IDerivationState_ // Used to avoid redundant propagations
     isPendingUnobservation: boolean // Used to push itself to global.pendingUnobservations at most once per batch.
 
-    observers_: Set<IDerivation>
+    observers_: Set<IDerivation> | null
 
     onBUO(): void
     onBO(): void
@@ -39,11 +36,11 @@ export interface IObservable extends IDepTreeNode {
 }
 
 export function hasObservers(observable: IObservable): boolean {
-    return observable.observers_ && observable.observers_.size > 0
+    return !!observable.observers_ && observable.observers_.size > 0
 }
 
 export function getObservers(observable: IObservable): Set<IDerivation> {
-    return observable.observers_
+    return observable.observers_ ?? new Set()
 }
 
 // function invariantObservers(observable: IObservable) {
@@ -68,7 +65,7 @@ export function addObserver(observable: IObservable, node: IDerivation) {
     // invariant(observable._observers.indexOf(node) === -1, "INTERNAL ERROR add already added node");
     // invariantObservers(observable);
 
-    observable.observers_.add(node)
+    ;(observable.observers_ ??= new Set()).add(node)
     if (observable.lowestObserverState_ > node.dependenciesState_) {
         observable.lowestObserverState_ = node.dependenciesState_
     }
@@ -81,8 +78,12 @@ export function removeObserver(observable: IObservable, node: IDerivation) {
     // invariant(globalState.inBatch > 0, "INTERNAL ERROR, remove should be called only inside batch");
     // invariant(observable._observers.indexOf(node) !== -1, "INTERNAL ERROR remove already removed node");
     // invariantObservers(observable);
-    observable.observers_.delete(node)
-    if (observable.observers_.size === 0) {
+    const observers = observable.observers_
+    if (!observers) {
+        return
+    }
+    observers.delete(node)
+    if (observers.size === 0) {
         // deleting last observer
         queueForUnobservation(observable)
     }
@@ -111,27 +112,60 @@ export function endBatch() {
     if (--globalState.inBatch === 0) {
         runReactions()
         // the batch is actually about to finish, all unobserving should happen here.
-        const list = globalState.pendingUnobservations
-        for (let i = 0; i < list.length; i++) {
-            const observable = list[i]
-            observable.isPendingUnobservation = false
-            if (observable.observers_.size === 0) {
-                if (observable.isBeingObserved) {
-                    // if this observable had reactive observers, trigger the hooks
-                    observable.isBeingObserved = false
-                    observable.onBUO()
-                }
-                if (observable instanceof ComputedValue) {
-                    // computed values are automatically teared down when the last observer leaves
-                    // this process happens recursively, this computed might be the last observabe of another, etc..
-                    observable.suspend_()
+        // Guard against re-entering this loop: an onBUO handler can dispose a Reaction,
+        // which calls startBatch/endBatch again while we're still iterating. Bail out of
+        // the nested call instead of recursing; the outer loop re-reads list.length on
+        // every iteration, so it picks up anything the nested dispose() pushes onto the
+        // same pendingUnobservations array.
+        if (!globalState.isRunningUnobservations) {
+            globalState.isRunningUnobservations = true
+            try {
+                const list = globalState.pendingUnobservations
+                for (let i = 0; i < list.length; i++) {
+                    const observable = list[i]
+                    observable.isPendingUnobservation = false
+                    if (!observable.observers_ || observable.observers_.size === 0) {
+                        if (observable.isBeingObserved) {
+                            // if this observable had reactive observers, trigger the hooks
+                            observable.isBeingObserved = false
+                            observable.onBUO()
+                        }
+                        if (observable instanceof ComputedValue) {
+                            // computed values are automatically teared down when the last observer leaves
+                            // this process happens recursively, this computed might be the last observabe of another, etc..
+                            observable.suspend_()
+                        }
+                    }
                 }
+                globalState.pendingUnobservations = []
+            } finally {
+                // Always release the guard, even if an onBUO handler (user code) threw,
+                // otherwise every future endBatch() would see isRunningUnobservations
+                // stuck true and silently stop draining pendingUnobservations forever.
+                globalState.isRunningUnobservations = false
             }
         }
-        globalState.pendingUnobservations = []
     }
 }
 
+/**
+ * Marks an observable as observed, cascading into the dependencies of a ComputedValue.
+ * Unobservation already cascades (`suspend_` -> `clearObserving`), observation normally
+ * only does so by accident: a newly observed computed usually recomputes and re-reports
+ * its dependencies. When it serves a cached value instead nothing re-reports them, so the
+ * transition has to be propagated by hand. See #4547.
+ */
+export function markObserved(observable: IObservable) {
+    if (observable.isBeingObserved) {
+        return
+    }
+    observable.isBeingObserved = true
+    observable.onBO()
+    // No queueForUnobservation here: the observer links already exist, so the regular
+    // suspend_ -> clearObserving -> removeObserver teardown still delivers the onBUO.
+    observable.observing_?.forEach(markObserved)
+}
+
 export function reportObserved(observable: IObservable): boolean {
     checkIfStateReadsAreAllowed(observable)
 
@@ -152,7 +186,10 @@ export function reportObserved(observable: IObservable): boolean {
             }
         }
         return observable.isBeingObserved
-    } else if (observable.observers_.size === 0 && globalState.inBatch > 0) {
+    } else if (
+        (!observable.observers_ || observable.observers_.size === 0) &&
+        globalState.inBatch > 0
+    ) {
         queueForUnobservation(observable)
     }
 
@@ -190,11 +227,8 @@ export function propagateChanged(observable: IObservable) {
     observable.lowestObserverState_ = IDerivationState_.STALE_
 
     // Ideally we use for..of here, but the downcompiled version is really slow...
-    observable.observers_.forEach(d => {
+    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_
@@ -210,12 +244,9 @@ export function propagateChangeConfirmed(observable: IObservable) {
     }
     observable.lowestObserverState_ = IDerivationState_.STALE_
 
-    observable.observers_.forEach(d => {
+    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.
         ) {
@@ -233,7 +264,7 @@ export function propagateMaybeChanged(observable: IObservable) {
     }
     observable.lowestObserverState_ = IDerivationState_.POSSIBLY_STALE_
 
-    observable.observers_.forEach(d => {
+    observable.observers_?.forEach(d => {
         if (d.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {
             d.dependenciesState_ = IDerivationState_.POSSIBLY_STALE_
             d.onBecomeStale_()
@@ -241,42 +272,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"

package/src/mobx.ts

@@ -16,13 +16,14 @@
  *
  */
 import { die } from "./errors"
-import { getGlobal } from "./utils/global"
-;["Symbol", "Map", "Set"].forEach(m => {
-    let g = getGlobal()
-    if (typeof g[m] === "undefined") {
-        die(`MobX requires global '${m}' to be available or polyfilled`)
-    }
-})
+if (__DEV__) {
+    const g = globalThis as any
+    ;["Symbol", "Map", "Set", "Proxy"].forEach(m => {
+        if (typeof g[m] === "undefined") {
+            die(`MobX requires global '${m}' to be available or polyfilled`)
+        }
+    })
+}
 
 import { spy, getDebugName, $mobx } from "./internal"
 
@@ -38,7 +39,10 @@ export {
     spy,
     IComputedValue,
     IEqualsComparer,
-    comparer,
+    compareDefault,
+    compareIdentity,
+    compareStructural,
+    compareShallow,
     IEnhancer,
     IInterceptable,
     IInterceptor,
@@ -72,9 +76,14 @@ export {
     IObservableSetInitialValues,
     transaction,
     observable,
+    observableRef,
+    observableShallow,
+    observableDeep,
+    observableStruct,
     IObservableFactory,
     CreateObservableOptions,
     computed,
+    computedStruct,
     IComputedFactory,
     isObservable,
     isObservableProp,
@@ -90,6 +99,7 @@ export {
     when,
     IWhenOptions,
     action,
+    actionBound,
     isAction,
     runInAction,
     IActionFactory,
@@ -106,13 +116,13 @@ export {
     onBecomeObserved,
     onBecomeUnobserved,
     flow,
+    flowBound,
     isFlow,
     flowResult,
     CancellablePromise,
     FlowCancellationError,
     isFlowCancellationError,
     toJS,
-    trace,
     IObserverTree,
     IDependencyTree,
     getDependencyTree,
@@ -138,6 +148,7 @@ export {
     makeObservable,
     makeAutoObservable,
     autoAction as _autoAction,
+    autoActionBound as _autoActionBound,
     AnnotationsMap,
     AnnotationMapEntry,
     override
@@ -145,7 +156,7 @@ export {
 
 // Devtools support
 declare const __MOBX_DEVTOOLS_GLOBAL_HOOK__: { injectMobx: (any) => void }
-if (typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === "object") {
+if (__DEV__ && typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === "object") {
     // See: https://github.com/andykog/mobx-devtools/
     __MOBX_DEVTOOLS_GLOBAL_HOOK__.injectMobx({
         spy,

package/src/types/actionannotation.ts

@@ -16,8 +16,7 @@ export function createActionAnnotation(name: string, options?: object): Annotati
         annotationType_: name,
         options_: options,
         make_,
-        extend_,
-        decorate_20223_
+        extend_
     }
 }
 
@@ -62,12 +61,12 @@ function extend_(
     return adm.defineProperty_(key, actionDescriptor, proxyTrap)
 }
 
-function decorate_20223_(this: Annotation, mthd, context: DecoratorContext) {
+export function decorateAction20223_(annotation: Annotation, mthd, context: DecoratorContext) {
     if (__DEV__) {
         assert20223DecoratorType(context, ["method", "field"])
     }
     const { kind, name, addInitializer } = context
-    const ann = this
+    const ann = annotation
 
     const _createAction = m =>
         createAction(ann.options_?.name ?? name!.toString(), m, ann.options_?.autoAction ?? false)
@@ -91,7 +90,7 @@ function decorate_20223_(this: Annotation, mthd, context: DecoratorContext) {
             mthd = _createAction(mthd)
         }
 
-        if (this.options_?.bound) {
+        if (ann.options_?.bound) {
             addInitializer(function () {
                 const self = this as any
                 const bound = self[name].bind(self)
@@ -103,10 +102,7 @@ function decorate_20223_(this: Annotation, mthd, context: DecoratorContext) {
         return mthd
     }
 
-    die(
-        `Cannot apply '${ann.annotationType_}' to '${String(name)}' (kind: ${kind}):` +
-            `\n'${ann.annotationType_}' can only be used on properties with a function value.`
-    )
+    die(43, ann.annotationType_, String(name), kind)
 }
 
 function assertActionDescriptor(

package/src/types/autoannotation.ts

@@ -1,16 +1,18 @@
 import {
     ObservableObjectAdministration,
     observable,
+    observableRef,
     Annotation,
     defineProperty,
     createAction,
     globalState,
     flow,
+    flowBound,
     computed,
     autoAction,
+    autoActionBound,
     isGenerator,
     MakeResult,
-    die,
     isAction
 } from "../internal"
 
@@ -23,8 +25,7 @@ export function createAutoAnnotation(options?: object): Annotation {
         annotationType_: AUTO,
         options_: options,
         make_,
-        extend_,
-        decorate_20223_
+        extend_
     }
 }
 
@@ -63,16 +64,16 @@ function make_(
     // function on proto -> autoAction/flow
     if (source !== adm.target_ && typeof descriptor.value === "function") {
         if (isGenerator(descriptor.value)) {
-            const flowAnnotation = this.options_?.autoBind ? flow.bound : flow
+            const flowAnnotation = this.options_?.autoBind ? flowBound : flow
             return flowAnnotation.make_(adm, key, descriptor, source)
         }
-        const actionAnnotation = this.options_?.autoBind ? autoAction.bound : autoAction
+        const actionAnnotation = this.options_?.autoBind ? autoActionBound : autoAction
         return actionAnnotation.make_(adm, key, descriptor, source)
     }
     // other -> observable
     // Copy props from proto as well, see test:
     // "decorate should work with Object.create"
-    let observableAnnotation = this.options_?.deep === false ? observable.ref : observable
+    let observableAnnotation = this.options_?.deep === false ? observableRef : observable
     // if function respect autoBind option
     if (typeof descriptor.value === "function" && this.options_?.autoBind) {
         descriptor.value = descriptor.value.bind(adm.proxy_ ?? adm.target_)
@@ -107,10 +108,6 @@ function extend_(
     if (typeof descriptor.value === "function" && this.options_?.autoBind) {
         descriptor.value = descriptor.value.bind(adm.proxy_ ?? adm.target_)
     }
-    let observableAnnotation = this.options_?.deep === false ? observable.ref : observable
+    let observableAnnotation = this.options_?.deep === false ? observableRef : observable
     return observableAnnotation.extend_(adm, key, descriptor, proxyTrap)
 }
-
-function decorate_20223_(this: Annotation, desc, context: ClassGetterDecoratorContext) {
-    die(`'${this.annotationType_}' cannot be used as a decorator`)
-}