mobx 6.1.4 → 6.1.8

package/dist/types/observablearray.d.ts

@@ -51,7 +51,7 @@ export declare class ObservableArrayAdministration implements IInterceptable<IAr
     dehancer: any;
     proxy_: IObservableArray<any>;
     lastKnownLength_: number;
-    constructor(name: any, enhancer: IEnhancer<any>, owned_: boolean, legacyMode_: boolean);
+    constructor(name: string | undefined, enhancer: IEnhancer<any>, owned_: boolean, legacyMode_: boolean);
     dehanceValue_(value: any): any;
     dehanceValues_(values: any[]): any[];
     intercept_(handler: IInterceptor<IArrayWillChange<any> | IArrayWillSplice<any>>): Lambda;

package/dist/types/type-utils.d.ts

@@ -1,4 +1,4 @@
 import { IDepTreeNode } from "../internal";
-export declare function getAtom(thing: any, property?: string): IDepTreeNode;
+export declare function getAtom(thing: any, property?: PropertyKey): IDepTreeNode;
 export declare function getAdministration(thing: any, property?: string): any;
 export declare function getDebugName(thing: any, property?: string): string;

package/package.json

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

package/src/api/annotation.ts

@@ -19,7 +19,6 @@ export type Annotation = {
         proxyTrap: boolean
     ): boolean | null
     options_?: any
-    isDecorator_?: boolean
 }
 
 export type AnnotationMapEntry =

package/src/api/autorun.ts

@@ -42,7 +42,8 @@ export function autorun(
         if (isAction(view)) die("Autorun does not accept actions since actions are untrackable")
     }
 
-    const name: string = (opts && opts.name) || (view as any).name || "Autorun@" + getNextId()
+    const name: string =
+        opts?.name ?? (__DEV__ ? (view as any).name || "Autorun@" + getNextId() : "Autorun")
     const runSync = !opts.scheduler && !opts.delay
     let reaction: Reaction
 
@@ -110,7 +111,7 @@ export function reaction<T>(
             die("First and second argument to reaction should be functions")
         if (!isPlainObject(opts)) die("Third argument of reactions should be an object")
     }
-    const name = opts.name || "Reaction@" + getNextId()
+    const name = opts.name ?? (__DEV__ ? "Reaction@" + getNextId() : "Reaction")
     const effectAction = action(
         name,
         opts.onError ? wrapErrorHandler(opts.onError, effect) : effect

package/src/api/computed.ts

@@ -54,7 +54,7 @@ export const computed: IComputedFactory = function computed(arg1, arg2) {
     }
     const opts: IComputedValueOptions<any> = isPlainObject(arg2) ? arg2 : {}
     opts.get = arg1
-    opts.name = opts.name || arg1.name || "" /* for generated name */
+    opts.name ||= arg1.name || "" /* for generated name */
 
     return new ComputedValue(opts)
 } as any

package/src/api/decorators.ts

@@ -38,10 +38,7 @@ export function storeAnnotation(prototype: any, key: PropertyKey, annotation: An
 
     // Ignore override
     if (!isOverride(annotation)) {
-        prototype[storedAnnotationsSymbol][key] = {
-            ...annotation,
-            isDecorator_: true
-        }
+        prototype[storedAnnotationsSymbol][key] = annotation
     }
 }
 

package/src/api/iscomputed.ts

@@ -1,6 +1,6 @@
 import { $mobx, getAtom, isComputedValue, isObservableObject, die, isStringish } from "../internal"
 
-export function _isComputed(value, property?: string): boolean {
+export function _isComputed(value, property?: PropertyKey): boolean {
     if (property !== undefined) {
         if (isObservableObject(value) === false) return false
         if (!value[$mobx].values_.has(property)) return false
@@ -18,7 +18,7 @@ export function isComputed(value: any): boolean {
     return _isComputed(value)
 }
 
-export function isComputedProp(value: any, propName: string): boolean {
+export function isComputedProp(value: any, propName: PropertyKey): boolean {
     if (__DEV__ && !isStringish(propName))
         return die(`isComputed expected a property name as second argument`)
     return _isComputed(value, propName)

package/src/api/makeObservable.ts

@@ -63,9 +63,17 @@ export function makeAutoObservable<T extends object, AdditionalKeys extends Prop
     const adm: ObservableObjectAdministration = asObservableObject(target, options)[$mobx]
     startBatch()
     try {
+        // Use cached inferred annotations if available (only in classes)
         if (target[inferredAnnotationsSymbol]) {
-            for (let key in target[inferredAnnotationsSymbol]) {
-                adm.make_(key, target[inferredAnnotationsSymbol][key])
+            target[inferredAnnotationsSymbol].forEach((value, key) => adm.make_(key, value))
+            // Overrides are not cached, unless `true`, see #2832
+            if (overrides) {
+                ownKeys(overrides).forEach(key => {
+                    const annotation = overrides[key]
+                    if (annotation !== true) {
+                        adm.make_(key, annotation)
+                    }
+                })
             }
         } else {
             const ignoreKeys = { [$mobx]: 1, [inferredAnnotationsSymbol]: 1, constructor: 1 }

package/src/api/observable.ts

@@ -125,7 +125,7 @@ function createObservable(v: any, arg2?: any, arg3?: any) {
     if (typeof v === "object" && v !== null) return v
 
     // anything else
-    return observable.box(v)
+    return observable.box(v, arg2)
 }
 Object.assign(createObservable, observableDecoratorAnnotation)
 

package/src/api/when.ts

@@ -43,8 +43,11 @@ function _when(predicate: () => boolean, effect: Lambda, opts: IWhenOptions): IR
         }, opts.timeout)
     }
 
-    opts.name = opts.name || "When@" + getNextId()
-    const effectAction = createAction(opts.name + "-effect", effect as Function)
+    opts.name = __DEV__ ? opts.name || "When@" + getNextId() : "When"
+    const effectAction = createAction(
+        __DEV__ ? opts.name + "-effect" : "When-effect",
+        effect as Function
+    )
     // eslint-disable-next-line
     var disposer = autorun(r => {
         // predicate should not change state

package/src/core/atom.ts

@@ -33,7 +33,7 @@ export class Atom implements IAtom {
      * Create a new atom. For debugging purposes it is recommended to give it a name.
      * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.
      */
-    constructor(public name_ = "Atom@" + getNextId()) {}
+    constructor(public name_ = __DEV__ ? "Atom@" + getNextId() : "Atom") {}
 
     // onBecomeObservedListeners
     public onBOL: Set<Lambda> | undefined

package/src/core/computedvalue.ts

@@ -88,7 +88,6 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     lastAccessedBy_ = 0
     lowestObserverState_ = IDerivationState_.UP_TO_DATE_
     unboundDepsCount_ = 0
-    mapid_ = "#" + getNextId()
     protected value_: T | undefined | CaughtException = new CaughtException(null)
     name_: string
     triggeredBy_?: string
@@ -117,8 +116,13 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     constructor(options: IComputedValueOptions<T>) {
         if (!options.get) die(31)
         this.derivation = options.get!
-        this.name_ = options.name || "ComputedValue@" + getNextId()
-        if (options.set) this.setter_ = createAction(this.name_ + "-setter", options.set) as any
+        this.name_ = options.name || (__DEV__ ? "ComputedValue@" + getNextId() : "ComputedValue")
+        if (options.set) {
+            this.setter_ = createAction(
+                __DEV__ ? this.name_ + "-setter" : "ComputedValue-setter",
+                options.set
+            ) as any
+        }
         this.equals_ =
             options.equals ||
             ((options as any).compareStructural || (options as any).struct

package/src/core/derivation.ts

@@ -51,7 +51,6 @@ export interface IDerivation extends IDepTreeNode {
      * amount of dependencies used by the derivation in this run, which has not been bound yet.
      */
     unboundDepsCount_: number
-    mapid_: string
     onBecomeStale_(): void
     isTracing_: TraceMode
 

package/src/core/reaction.ts

@@ -57,7 +57,6 @@ export class Reaction implements IDerivation, IReactionPublic {
     diffValue_ = 0
     runId_ = 0
     unboundDepsCount_ = 0
-    mapid_ = "#" + getNextId()
     isDisposed_ = false
     isScheduled_ = false
     isTrackPending_ = false
@@ -65,7 +64,7 @@ export class Reaction implements IDerivation, IReactionPublic {
     isTracing_: TraceMode = TraceMode.NONE
 
     constructor(
-        public name_: string = "Reaction@" + getNextId(),
+        public name_: string = __DEV__ ? "Reaction@" + getNextId() : "Reaction",
         private onInvalidate_: () => void,
         private errorHandler_?: (error: any, derivation: IDerivation) => void,
         public requiresObservable_ = false

package/src/types/actionannotation.ts

@@ -9,7 +9,8 @@ import {
     isFunction,
     Annotation,
     recordAnnotationApplied,
-    globalState
+    globalState,
+    storedAnnotationsSymbol
 } from "../internal"
 
 export function createActionAnnotation(name: string, options?: object): Annotation {
@@ -61,7 +62,7 @@ function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
     }
     if (annotated) {
         recordAnnotationApplied(adm, this, key)
-    } else if (!this.isDecorator_) {
+    } else if (!adm.target_[storedAnnotationsSymbol]?.[key]) {
         // Throw on missing key, except for decorators:
         // Decorator annotations are collected from whole prototype chain.
         // When called from super() some props may not exist yet.

package/src/types/computedannotation.ts

@@ -4,7 +4,8 @@ import {
     objectPrototype,
     die,
     Annotation,
-    recordAnnotationApplied
+    recordAnnotationApplied,
+    storedAnnotationsSymbol
 } from "../internal"
 
 export function createComputedAnnotation(name: string, options?: object): Annotation {
@@ -36,7 +37,7 @@ function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
         }
         source = Object.getPrototypeOf(source)
     }
-    if (!this.isDecorator_) {
+    if (!adm.target_[storedAnnotationsSymbol]?.[key]) {
         // Throw on missing key, except for decorators:
         // Decorator annotations are collected from whole prototype chain.
         // When called from super() some props may not exist yet.

package/src/types/flowannotation.ts

@@ -9,7 +9,8 @@ import {
     isFlow,
     recordAnnotationApplied,
     isFunction,
-    globalState
+    globalState,
+    storedAnnotationsSymbol
 } from "../internal"
 
 export function createFlowAnnotation(name: string, options?: object): Annotation {
@@ -51,7 +52,7 @@ function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
     }
     if (annotated) {
         recordAnnotationApplied(adm, this, key)
-    } else if (!this.isDecorator_) {
+    } else if (!adm.target_[storedAnnotationsSymbol]?.[key]) {
         // Throw on missing key, except for decorators:
         // Decorator annotations are collected from whole prototype chain.
         // When called from super() some props may not exist yet.

package/src/types/legacyobservablearray.ts

@@ -42,7 +42,7 @@ class LegacyObservableArray<T> extends StubArray {
     constructor(
         initialValues: T[] | undefined,
         enhancer: IEnhancer<T>,
-        name = "ObservableArray@" + getNextId(),
+        name = __DEV__ ? "ObservableArray@" + getNextId() : "ObservableArray",
         owned = false
     ) {
         super()

package/src/types/observableannotation.ts

@@ -5,7 +5,8 @@ import {
     die,
     Annotation,
     recordAnnotationApplied,
-    objectPrototype
+    objectPrototype,
+    storedAnnotationsSymbol
 } from "../internal"
 
 export function createObservableAnnotation(name: string, options?: object): Annotation {
@@ -39,7 +40,7 @@ function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
         }
         source = Object.getPrototypeOf(source)
     }
-    if (!this.isDecorator_) {
+    if (!adm.target_[storedAnnotationsSymbol]?.[key]) {
         // Throw on missing key, except for decorators:
         // Decorator annotations are collected from whole prototype chain.
         // When called from super() some props may not exist yet.

package/src/types/observablearray.ts

@@ -124,13 +124,14 @@ export class ObservableArrayAdministration
     lastKnownLength_ = 0
 
     constructor(
-        name,
+        name = __DEV__ ? "ObservableArray@" + getNextId() : "ObservableArray",
         enhancer: IEnhancer<any>,
         public owned_: boolean,
         public legacyMode_: boolean
     ) {
-        this.atom_ = new Atom(name || "ObservableArray@" + getNextId())
-        this.enhancer_ = (newV, oldV) => enhancer(newV, oldV, name + "[..]")
+        this.atom_ = new Atom(name)
+        this.enhancer_ = (newV, oldV) =>
+            enhancer(newV, oldV, __DEV__ ? name + "[..]" : "ObservableArray[..]")
     }
 
     dehanceValue_(value: any): any {
@@ -340,7 +341,7 @@ export class ObservableArrayAdministration
 export function createObservableArray<T>(
     initialValues: T[] | undefined,
     enhancer: IEnhancer<T>,
-    name = "ObservableArray@" + getNextId(),
+    name = __DEV__ ? "ObservableArray@" + getNextId() : "ObservableArray",
     owned = false
 ): IObservableArray<T> {
     assertProxies()

package/src/types/observablemap.ts

@@ -97,12 +97,12 @@ export class ObservableMap<K = any, V = any>
     constructor(
         initialData?: IObservableMapInitialValues<K, V>,
         public enhancer_: IEnhancer<V> = deepEnhancer,
-        public name_ = "ObservableMap@" + getNextId()
+        public name_ = __DEV__ ? "ObservableMap@" + getNextId() : "ObservableMap"
     ) {
         if (!isFunction(Map)) {
             die(18)
         }
-        this.keysAtom_ = createAtom(`${this.name_}.keys()`)
+        this.keysAtom_ = createAtom(__DEV__ ? `${this.name_}.keys()` : "ObservableMap.keys()")
         this.data_ = new Map()
         this.hasMap_ = new Map()
         this.merge(initialData)
@@ -120,7 +120,7 @@ export class ObservableMap<K = any, V = any>
             const newEntry = (entry = new ObservableValue(
                 this.has_(key),
                 referenceEnhancer,
-                `${this.name_}.${stringifyKey(key)}?`,
+                __DEV__ ? `${this.name_}.${stringifyKey(key)}?` : "ObservableMap.key?",
                 false
             ))
             this.hasMap_.set(key, newEntry)
@@ -228,7 +228,7 @@ export class ObservableMap<K = any, V = any>
             const observable = new ObservableValue(
                 newValue,
                 this.enhancer_,
-                `${this.name_}.${stringifyKey(key)}`,
+                __DEV__ ? `${this.name_}.${stringifyKey(key)}` : "ObservableMap.key",
                 false
             )
             this.data_.set(key, observable)

package/src/types/observableobject.ts

@@ -44,10 +44,12 @@ import {
     isOverride,
     defineProperty,
     inferAnnotationFromDescriptor,
+    getDebugName,
+    getAdministration,
     objectPrototype
 } from "../internal"
 
-// adm[inferredAnnotationsSymbol] = { foo: annotation, ... }
+// closestPrototypeofTarget[inferredAnnotationsSymbol] = new Map<PropertyKes, Annotation>()
 export const inferredAnnotationsSymbol = Symbol("mobx-inferred-annotations")
 
 const descriptorCache = Object.create(null)
@@ -107,7 +109,7 @@ export class ObservableObjectAdministration
         // Bind automatically inferred actions?
         public autoBind_: boolean = false
     ) {
-        this.keysAtom_ = new Atom(name_ + ".keys")
+        this.keysAtom_ = new Atom(__DEV__ ? `${this.name_}.keys` : "ObservableObject.keys")
         // Optimization: we use this frequently
         this.isPlainObject_ = isPlainObject(this.target_)
         if (__DEV__ && !isAnnotation(this.defaultAnnotation_)) {
@@ -224,7 +226,7 @@ export class ObservableObjectAdministration
             entry = new ObservableValue(
                 key in this.target_,
                 referenceEnhancer,
-                `${this.name_}.${stringifyKey(key)}?`,
+                __DEV__ ? `${this.name_}.${stringifyKey(key)}?` : "ObservableObject.key?",
                 false
             )
             this.pendingKeys_.set(key, entry)
@@ -280,7 +282,7 @@ export class ObservableObjectAdministration
 
     inferAnnotation_(key: PropertyKey): Annotation | false {
         // Inherited is fine - annotation cannot differ in subclass
-        let annotation = this.target_[inferredAnnotationsSymbol]?.[key]
+        let annotation = this.target_[inferredAnnotationsSymbol]?.get(key)
         if (annotation) return annotation
 
         let current = this.target_
@@ -308,9 +310,9 @@ export class ObservableObjectAdministration
             // We could also place it on furthest proto, shoudn't matter
             const closestProto = Object.getPrototypeOf(this.target_)
             if (!hasProp(closestProto, inferredAnnotationsSymbol)) {
-                addHiddenProp(closestProto, inferredAnnotationsSymbol, {})
+                addHiddenProp(closestProto, inferredAnnotationsSymbol, new Map())
             }
-            closestProto[inferredAnnotationsSymbol][key] = annotation
+            closestProto[inferredAnnotationsSymbol].set(key, annotation)
         }
 
         return annotation
@@ -421,7 +423,7 @@ export class ObservableObjectAdministration
             const observable = new ObservableValue(
                 value,
                 enhancer,
-                `${this.name_}.${stringifyKey(key)}`,
+                __DEV__ ? `${this.name_}.${key.toString()}` : "ObservableObject.key",
                 false
             )
 
@@ -461,7 +463,7 @@ export class ObservableObjectAdministration
                 })
                 if (!change) return null
             }
-            options.name ||= `${this.name_}.${stringifyKey(key)}`
+            options.name ||= __DEV__ ? `${this.name_}.${key.toString()}` : "ObservableObject.key"
             options.context = this.proxy_ || this.target_
             const cachedDescriptor = getCachedObservablePropDescriptor(key)
             const descriptor = {
@@ -645,19 +647,32 @@ export function asObservableObject(
         die(`Options can't be provided for already observable objects.`)
     }
 
-    if (hasProp(target, $mobx)) return target
+    if (hasProp(target, $mobx)) {
+        if (__DEV__ && !(getAdministration(target) instanceof ObservableObjectAdministration)) {
+            die(
+                `Cannot convert '${getDebugName(target)}' into observable object:` +
+                    `\nThe target is already observable of different type.` +
+                    `\nExtending builtins is not supported.`
+            )
+        }
+        return target
+    }
 
     if (__DEV__ && !Object.isExtensible(target))
         die("Cannot make the designated object observable; it is not extensible")
 
     const name =
         options?.name ??
-        `${isPlainObject(target) ? "ObservableObject" : target.constructor.name}@${getNextId()}`
+        (__DEV__
+            ? `${
+                  isPlainObject(target) ? "ObservableObject" : target.constructor.name
+              }@${getNextId()}`
+            : "ObservableObject")
 
     const adm = new ObservableObjectAdministration(
         target,
         new Map(),
-        stringifyKey(name),
+        String(name),
         getAnnotationFromOptions(options),
         options?.autoBind
     )
@@ -702,9 +717,7 @@ export function recordAnnotationApplied(
         adm.appliedAnnotations_![key] = annotation
     }
     // Remove applied decorator annotation so we don't try to apply it again in subclass constructor
-    if (annotation.isDecorator_) {
-        delete adm.target_[storedAnnotationsSymbol][key]
-    }
+    delete adm.target_[storedAnnotationsSymbol]?.[key]
 }
 
 function assertAnnotable(

package/src/types/observableset.ts

@@ -74,7 +74,7 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     constructor(
         initialData?: IObservableSetInitialValues<T>,
         enhancer: IEnhancer<T> = deepEnhancer,
-        public name_ = "ObservableSet@" + getNextId()
+        public name_ = __DEV__ ? "ObservableSet@" + getNextId() : "ObservableSet"
     ) {
         if (!isFunction(Set)) {
             die(22)

package/src/types/observablevalue.ts

@@ -71,7 +71,7 @@ export class ObservableValue<T>
     constructor(
         value: T,
         public enhancer: IEnhancer<T>,
-        public name_ = "ObservableValue@" + getNextId(),
+        public name_ = __DEV__ ? "ObservableValue@" + getNextId() : "ObservableValue",
         notifySpy = true,
         private equals: IEqualsComparer<any> = comparer.default
     ) {

package/src/types/type-utils.ts

@@ -1,3 +1,4 @@
+import { isAction } from "../api/action"
 import {
     $mobx,
     IDepTreeNode,
@@ -12,7 +13,7 @@ import {
     isFunction
 } from "../internal"
 
-export function getAtom(thing: any, property?: string): IDepTreeNode {
+export function getAtom(thing: any, property?: PropertyKey): IDepTreeNode {
     if (typeof thing === "object" && thing !== null) {
         if (isObservableArray(thing)) {
             if (property !== undefined) die(23)
@@ -57,9 +58,15 @@ export function getAdministration(thing: any, property?: string) {
 
 export function getDebugName(thing: any, property?: string): string {
     let named
-    if (property !== undefined) named = getAtom(thing, property)
-    else if (isObservableObject(thing) || isObservableMap(thing) || isObservableSet(thing))
+    if (property !== undefined) {
+        named = getAtom(thing, property)
+    } else if (isAction(thing)) {
+        return thing.name
+    } else if (isObservableObject(thing) || isObservableMap(thing) || isObservableSet(thing)) {
         named = getAdministration(thing)
-    else named = getAtom(thing) // valid for arrays as well
+    } else {
+        // valid for arrays as well
+        named = getAtom(thing)
+    }
     return named.name_
 }

package/src/utils/global.ts

@@ -4,6 +4,9 @@ declare const self: any
 const mockGlobal = {}
 
 export function getGlobal() {
+    if (typeof globalThis !== "undefined") {
+        return globalThis
+    }
     if (typeof window !== "undefined") {
         return window
     }