mobx 6.1.8 → 6.9.0

package/src/types/observableobject.ts

@@ -33,7 +33,6 @@ import {
     startBatch,
     stringifyKey,
     globalState,
-    observable,
     ADD,
     UPDATE,
     die,
@@ -43,15 +42,13 @@ import {
     ownKeys,
     isOverride,
     defineProperty,
-    inferAnnotationFromDescriptor,
-    getDebugName,
+    autoAnnotation,
     getAdministration,
-    objectPrototype
+    getDebugName,
+    objectPrototype,
+    MakeResult
 } from "../internal"
 
-// closestPrototypeofTarget[inferredAnnotationsSymbol] = new Map<PropertyKes, Annotation>()
-export const inferredAnnotationsSymbol = Symbol("mobx-inferred-annotations")
-
 const descriptorCache = Object.create(null)
 
 export type IObjectDidChange<T = any> = {
@@ -91,7 +88,8 @@ export type IObjectWillChange<T = any> =
 const REMOVE = "remove"
 
 export class ObservableObjectAdministration
-    implements IInterceptable<IObjectWillChange>, IListenable {
+    implements IInterceptable<IObjectWillChange>, IListenable
+{
     keysAtom_: IAtom
     changeListeners_
     interceptors_
@@ -105,9 +103,7 @@ export class ObservableObjectAdministration
         public values_ = new Map<PropertyKey, ObservableValue<any> | ComputedValue<any>>(),
         public name_: string,
         // Used anytime annotation is not explicitely provided
-        public defaultAnnotation_: Annotation = observable,
-        // Bind automatically inferred actions?
-        public autoBind_: boolean = false
+        public defaultAnnotation_: Annotation = autoAnnotation
     ) {
         this.keysAtom_ = new Atom(__DEV__ ? `${this.name_}.keys` : "ObservableObject.keys")
         // Optimization: we use this frequently
@@ -115,9 +111,6 @@ export class ObservableObjectAdministration
         if (__DEV__ && !isAnnotation(this.defaultAnnotation_)) {
             die(`defaultAnnotation must be valid annotation`)
         }
-        if (__DEV__ && typeof this.autoBind_ !== "boolean") {
-            die(`autoBind must be boolean`)
-        }
         if (__DEV__) {
             // Prepare structure for tracking which fields were already annotated
             this.appliedAnnotations_ = {}
@@ -143,7 +136,9 @@ export class ObservableObjectAdministration
                 name: key,
                 newValue
             })
-            if (!change) return null
+            if (!change) {
+                return null
+            }
             newValue = (change as any).newValue
         }
         newValue = (observable as any).prepareNewValue_(newValue)
@@ -165,10 +160,16 @@ export class ObservableObjectAdministration
                       }
                     : null
 
-            if (__DEV__ && notifySpy) spyReportStart(change!)
+            if (__DEV__ && notifySpy) {
+                spyReportStart(change!)
+            }
             ;(observable as ObservableValue<any>).setNewValue_(newValue)
-            if (notify) notifyListeners(this, change)
-            if (__DEV__ && notifySpy) spyReportEnd()
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (__DEV__ && notifySpy) {
+                spyReportEnd()
+            }
         }
         return true
     }
@@ -184,7 +185,7 @@ export class ObservableObjectAdministration
     /**
      * @param {PropertyKey} key
      * @param {any} value
-     * @param {Annotation|boolean} annotation true - infer from descriptor, false - copy as is
+     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
      * @param {boolean} proxyTrap whether it's called from proxy trap
      * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
      */
@@ -236,23 +237,49 @@ export class ObservableObjectAdministration
 
     /**
      * @param {PropertyKey} key
-     * @param {Annotation|boolean} annotation true - infer from object or it's prototype, false - ignore
+     * @param {Annotation|boolean} annotation true - use default annotation, false - ignore prop
      */
     make_(key: PropertyKey, annotation: Annotation | boolean): void {
         if (annotation === true) {
-            annotation = this.inferAnnotation_(key)
+            annotation = this.defaultAnnotation_
         }
         if (annotation === false) {
             return
         }
         assertAnnotable(this, annotation, key)
-        annotation.make_(this, key)
+        if (!(key in this.target_)) {
+            // 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.
+            // However we don't have to worry about missing prop,
+            // because the decorator must have been applied to something.
+            if (this.target_[storedAnnotationsSymbol]?.[key]) {
+                return // will be annotated by subclass constructor
+            } else {
+                die(1, annotation.annotationType_, `${this.name_}.${key.toString()}`)
+            }
+        }
+        let source = this.target_
+        while (source && source !== objectPrototype) {
+            const descriptor = getDescriptor(source, key)
+            if (descriptor) {
+                const outcome = annotation.make_(this, key, descriptor, source)
+                if (outcome === MakeResult.Cancel) {
+                    return
+                }
+                if (outcome === MakeResult.Break) {
+                    break
+                }
+            }
+            source = Object.getPrototypeOf(source)
+        }
+        recordAnnotationApplied(this, annotation, key)
     }
 
     /**
      * @param {PropertyKey} key
      * @param {PropertyDescriptor} descriptor
-     * @param {Annotation|boolean} annotation true - infer from descriptor, false - copy as is
+     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
      * @param {boolean} proxyTrap whether it's called from proxy trap
      * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
      */
@@ -263,11 +290,7 @@ export class ObservableObjectAdministration
         proxyTrap: boolean = false
     ): boolean | null {
         if (annotation === true) {
-            annotation = inferAnnotationFromDescriptor(
-                descriptor,
-                this.defaultAnnotation_,
-                this.autoBind_
-            )
+            annotation = this.defaultAnnotation_
         }
         if (annotation === false) {
             return this.defineProperty_(key, descriptor, proxyTrap)
@@ -280,44 +303,6 @@ export class ObservableObjectAdministration
         return outcome
     }
 
-    inferAnnotation_(key: PropertyKey): Annotation | false {
-        // Inherited is fine - annotation cannot differ in subclass
-        let annotation = this.target_[inferredAnnotationsSymbol]?.get(key)
-        if (annotation) return annotation
-
-        let current = this.target_
-        while (current && current !== objectPrototype) {
-            const descriptor = getDescriptor(current, key)
-            if (descriptor) {
-                annotation = inferAnnotationFromDescriptor(
-                    descriptor,
-                    this.defaultAnnotation_,
-                    this.autoBind_
-                )
-                break
-            }
-            current = Object.getPrototypeOf(current)
-        }
-
-        // Not found (false means ignore)
-        if (annotation === undefined) {
-            die(1, "true", key)
-        }
-
-        // Cache the annotation.
-        // Note we can do this only because annotation and field can't change.
-        if (!this.isPlainObject_) {
-            // We could also place it on furthest proto, shoudn't matter
-            const closestProto = Object.getPrototypeOf(this.target_)
-            if (!hasProp(closestProto, inferredAnnotationsSymbol)) {
-                addHiddenProp(closestProto, inferredAnnotationsSymbol, new Map())
-            }
-            closestProto[inferredAnnotationsSymbol].set(key, annotation)
-        }
-
-        return annotation
-    }
-
     /**
      * @param {PropertyKey} key
      * @param {PropertyDescriptor} descriptor
@@ -347,7 +332,9 @@ export class ObservableObjectAdministration
                     type: ADD,
                     newValue: descriptor.value
                 })
-                if (!change) return null
+                if (!change) {
+                    return null
+                }
                 const { newValue } = change as any
                 if (descriptor.value !== newValue) {
                     descriptor = {
@@ -399,7 +386,9 @@ export class ObservableObjectAdministration
                     type: ADD,
                     newValue: value
                 })
-                if (!change) return null
+                if (!change) {
+                    return null
+                }
                 value = (change as any).newValue
             }
 
@@ -461,7 +450,9 @@ export class ObservableObjectAdministration
                     type: ADD,
                     newValue: undefined
                 })
-                if (!change) return null
+                if (!change) {
+                    return null
+                }
             }
             options.name ||= __DEV__ ? `${this.name_}.${key.toString()}` : "ObservableObject.key"
             options.context = this.proxy_ || this.target_
@@ -512,7 +503,9 @@ export class ObservableObjectAdministration
                 type: REMOVE
             })
             // Cancelled
-            if (!change) return null
+            if (!change) {
+                return null
+            }
         }
 
         // Delete
@@ -566,9 +559,15 @@ export class ObservableObjectAdministration
                     oldValue: value,
                     name: key
                 }
-                if (__DEV__ && notifySpy) spyReportStart(change!)
-                if (notify) notifyListeners(this, change)
-                if (__DEV__ && notifySpy) spyReportEnd()
+                if (__DEV__ && notifySpy) {
+                    spyReportStart(change!)
+                }
+                if (notify) {
+                    notifyListeners(this, change)
+                }
+                if (__DEV__ && notifySpy) {
+                    spyReportEnd()
+                }
             }
         } finally {
             endBatch()
@@ -582,8 +581,9 @@ export class ObservableObjectAdministration
      * for callback details
      */
     observe_(callback: (changes: IObjectDidChange) => void, fireImmediately?: boolean): Lambda {
-        if (__DEV__ && fireImmediately === true)
+        if (__DEV__ && fireImmediately === true) {
             die("`observe` doesn't support the fire immediately property for observable objects.")
+        }
         return registerListener(this, callback)
     }
 
@@ -607,9 +607,15 @@ export class ObservableObjectAdministration
                       } as const)
                     : null
 
-            if (__DEV__ && notifySpy) spyReportStart(change!)
-            if (notify) notifyListeners(this, change)
-            if (__DEV__ && notifySpy) spyReportEnd()
+            if (__DEV__ && notifySpy) {
+                spyReportStart(change!)
+            }
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (__DEV__ && notifySpy) {
+                spyReportEnd()
+            }
         }
 
         this.pendingKeys_?.get(key)?.set(true)
@@ -618,7 +624,7 @@ export class ObservableObjectAdministration
         this.keysAtom_.reportChanged()
     }
 
-    ownKeys_(): PropertyKey[] {
+    ownKeys_(): ArrayLike<string | symbol> {
         this.keysAtom_.reportObserved()
         return ownKeys(this.target_)
     }
@@ -658,8 +664,9 @@ export function asObservableObject(
         return target
     }
 
-    if (__DEV__ && !Object.isExtensible(target))
+    if (__DEV__ && !Object.isExtensible(target)) {
         die("Cannot make the designated object observable; it is not extensible")
+    }
 
     const name =
         options?.name ??
@@ -673,8 +680,7 @@ export function asObservableObject(
         target,
         new Map(),
         String(name),
-        getAnnotationFromOptions(options),
-        options?.autoBind
+        getAnnotationFromOptions(options)
     )
 
     addHiddenProp(target, $mobx, adm)
@@ -770,7 +776,7 @@ function assertAnnotable(
             `Cannot apply '${requestedAnnotationType}' to '${fieldName}':` +
                 `\nThe field is already annotated with '${currentAnnotationType}'.` +
                 `\nRe-annotating fields is not allowed.` +
-                `\nUse 'override' annotation for methods overriden by subclass.`
+                `\nUse 'override' annotation for methods overridden by subclass.`
         )
     }
 }

package/src/types/observableset.ts

@@ -65,7 +65,7 @@ export type ISetWillChange<T = any> =
 export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
     [$mobx] = ObservableSetMarker
     private data_: Set<any> = new Set()
-    private atom_: IAtom
+    atom_: IAtom
     changeListeners_
     interceptors_
     dehancer: any
@@ -96,7 +96,9 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     clear() {
         transaction(() => {
             untracked(() => {
-                for (const value of this.data_.values()) this.delete(value)
+                for (const value of this.data_.values()) {
+                    this.delete(value)
+                }
             })
         })
     }
@@ -120,7 +122,9 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
                 object: this,
                 newValue: value
             })
-            if (!change) return this
+            if (!change) {
+                return this
+            }
             // ideally, value = change.value would be done here, so that values can be
             // changed by interceptor. Same applies for other Set and Map api's.
         }
@@ -141,22 +145,30 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
                           newValue: value
                       }
                     : null
-            if (notifySpy && __DEV__) spyReportStart(change!)
-            if (notify) notifyListeners(this, change)
-            if (notifySpy && __DEV__) spyReportEnd()
+            if (notifySpy && __DEV__) {
+                spyReportStart(change!)
+            }
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (notifySpy && __DEV__) {
+                spyReportEnd()
+            }
         }
 
         return this
     }
 
-    delete(value: any) {
+    delete(value: T) {
         if (hasInterceptors(this)) {
             const change = interceptChange<ISetWillChange<T>>(this, {
                 type: DELETE,
                 object: this,
                 oldValue: value
             })
-            if (!change) return false
+            if (!change) {
+                return false
+            }
         }
         if (this.has(value)) {
             const notifySpy = __DEV__ && isSpyEnabled()
@@ -172,19 +184,25 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
                       }
                     : null
 
-            if (notifySpy && __DEV__) spyReportStart(change!)
+            if (notifySpy && __DEV__) {
+                spyReportStart(change!)
+            }
             transaction(() => {
                 this.atom_.reportChanged()
                 this.data_.delete(value)
             })
-            if (notify) notifyListeners(this, change)
-            if (notifySpy && __DEV__) spyReportEnd()
+            if (notify) {
+                notifyListeners(this, change)
+            }
+            if (notifySpy && __DEV__) {
+                spyReportEnd()
+            }
             return true
         }
         return false
     }
 
-    has(value: any) {
+    has(value: T) {
         this.atom_.reportObserved()
         return this.data_.has(this.dehanceValue_(value))
     }
@@ -243,8 +261,9 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     }
     observe_(listener: (changes: ISetDidChange<T>) => void, fireImmediately?: boolean): Lambda {
         // ... 'fireImmediately' could also be true?
-        if (__DEV__ && fireImmediately === true)
+        if (__DEV__ && fireImmediately === true) {
             die("`observe` doesn't support fireImmediately=true in combination with sets.")
+        }
         return registerListener(this, listener)
     }
 

package/src/types/observablevalue.ts

@@ -37,8 +37,8 @@ export type IValueDidChange<T = any> = {
     observableKind: "value"
     object: IObservableValue<T>
     debugObjectName: string
-    newValue: unknown
-    oldValue: unknown
+    newValue: T
+    oldValue: T | undefined
 }
 export type IBoxDidChange<T = any> =
     | {
@@ -46,22 +46,21 @@ export type IBoxDidChange<T = any> =
           observableKind: "value"
           object: IObservableValue<T>
           debugObjectName: string
-          newValue: unknown
+          newValue: T
       }
     | IValueDidChange<T>
 
 export interface IObservableValue<T> {
     get(): T
     set(value: T): void
-    intercept_(handler: IInterceptor<IValueWillChange<T>>): Lambda
-    observe_(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda
 }
 
 const CREATE = "create"
 
 export class ObservableValue<T>
     extends Atom
-    implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
+    implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable
+{
     hasUnreportedChange_ = false
     interceptors_
     changeListeners_
@@ -90,7 +89,9 @@ export class ObservableValue<T>
     }
 
     private dehanceValue(value: T): T {
-        if (this.dehancer !== undefined) return this.dehancer(value)
+        if (this.dehancer !== undefined) {
+            return this.dehancer(value)
+        }
         return value
     }
 
@@ -110,7 +111,9 @@ export class ObservableValue<T>
                 })
             }
             this.setNewValue_(newValue)
-            if (__DEV__ && notifySpy) spyReportEnd()
+            if (__DEV__ && notifySpy) {
+                spyReportEnd()
+            }
         }
     }
 
@@ -122,7 +125,9 @@ export class ObservableValue<T>
                 type: UPDATE,
                 newValue
             })
-            if (!change) return globalState.UNCHANGED
+            if (!change) {
+                return globalState.UNCHANGED
+            }
             newValue = change.newValue
         }
         // apply modifier
@@ -154,7 +159,7 @@ export class ObservableValue<T>
     }
 
     observe_(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda {
-        if (fireImmediately)
+        if (fireImmediately) {
             listener({
                 observableKind: "value",
                 debugObjectName: this.name_,
@@ -163,6 +168,7 @@ export class ObservableValue<T>
                 newValue: this.value_,
                 oldValue: undefined
             })
+        }
         return registerListener(this, listener)
     }
 

package/src/types/overrideannotation.ts

@@ -3,7 +3,8 @@ import {
     Annotation,
     hasProp,
     createDecoratorAnnotation,
-    ObservableObjectAdministration
+    ObservableObjectAdministration,
+    MakeResult
 } from "../internal"
 
 const OVERRIDE = "override"
@@ -18,7 +19,7 @@ export function isOverride(annotation: Annotation): boolean {
     return annotation.annotationType_ === OVERRIDE
 }
 
-function make_(adm: ObservableObjectAdministration, key): void {
+function make_(adm: ObservableObjectAdministration, key): MakeResult {
     // Must not be plain object
     if (__DEV__ && adm.isPlainObject_) {
         die(
@@ -33,6 +34,7 @@ function make_(adm: ObservableObjectAdministration, key): void {
                 `but no such annotated member was found on prototype.`
         )
     }
+    return MakeResult.Cancel
 }
 
 function extend_(adm, key, descriptor, proxyTrap): boolean {

package/src/types/type-utils.ts

@@ -16,23 +16,35 @@ import {
 export function getAtom(thing: any, property?: PropertyKey): IDepTreeNode {
     if (typeof thing === "object" && thing !== null) {
         if (isObservableArray(thing)) {
-            if (property !== undefined) die(23)
+            if (property !== undefined) {
+                die(23)
+            }
             return (thing as any)[$mobx].atom_
         }
         if (isObservableSet(thing)) {
-            return (thing as any)[$mobx]
+            return thing.atom_
         }
         if (isObservableMap(thing)) {
-            if (property === undefined) return thing.keysAtom_
+            if (property === undefined) {
+                return thing.keysAtom_
+            }
             const observable = thing.data_.get(property) || thing.hasMap_.get(property)
-            if (!observable) die(25, property, getDebugName(thing))
+            if (!observable) {
+                die(25, property, getDebugName(thing))
+            }
             return observable
         }
-        if (property && !thing[$mobx]) thing[property] // See #1072
+        if (property && !thing[$mobx]) {
+            thing[property]
+        } // See #1072
         if (isObservableObject(thing)) {
-            if (!property) return die(26)
+            if (!property) {
+                return die(26)
+            }
             const observable = (thing as any)[$mobx].values_.get(property)
-            if (!observable) die(27, property, getDebugName(thing))
+            if (!observable) {
+                die(27, property, getDebugName(thing))
+            }
             return observable
         }
         if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) {
@@ -48,11 +60,21 @@ export function getAtom(thing: any, property?: PropertyKey): IDepTreeNode {
 }
 
 export function getAdministration(thing: any, property?: string) {
-    if (!thing) die(29)
-    if (property !== undefined) return getAdministration(getAtom(thing, property))
-    if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) return thing
-    if (isObservableMap(thing) || isObservableSet(thing)) return thing
-    if (thing[$mobx]) return thing[$mobx]
+    if (!thing) {
+        die(29)
+    }
+    if (property !== undefined) {
+        return getAdministration(getAtom(thing, property))
+    }
+    if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) {
+        return thing
+    }
+    if (isObservableMap(thing) || isObservableSet(thing)) {
+        return thing
+    }
+    if (thing[$mobx]) {
+        return thing[$mobx]
+    }
     die(24, thing)
 }
 

package/src/utils/comparer.ts

@@ -17,7 +17,11 @@ function shallowComparer(a: any, b: any): boolean {
 }
 
 function defaultComparer(a: any, b: any): boolean {
-    return Object.is(a, b)
+    if (Object.is) {
+        return Object.is(a, b)
+    }
+
+    return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b
 }
 
 export const comparer = {