mobx 6.1.8 → 6.3.2

package/src/types/computedannotation.ts

@@ -1,12 +1,4 @@
-import {
-    ObservableObjectAdministration,
-    getDescriptor,
-    objectPrototype,
-    die,
-    Annotation,
-    recordAnnotationApplied,
-    storedAnnotationsSymbol
-} from "../internal"
+import { ObservableObjectAdministration, die, Annotation, MakeResult } from "../internal"
 
 export function createComputedAnnotation(name: string, options?: object): Annotation {
     return {
@@ -17,34 +9,12 @@ export function createComputedAnnotation(name: string, options?: object): Annota
     }
 }
 
-function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
-    let source = adm.target_
-    while (source && source !== objectPrototype) {
-        const descriptor = getDescriptor(source, key)
-        if (descriptor) {
-            assertComputedDescriptor(adm, this, key, descriptor)
-            const definePropertyOutcome = adm.defineComputedProperty_(key, {
-                ...this.options_,
-                get: descriptor.get,
-                set: descriptor.set
-            })
-            if (!definePropertyOutcome) {
-                // Intercepted
-                return
-            }
-            recordAnnotationApplied(adm, this, key)
-            return
-        }
-        source = Object.getPrototypeOf(source)
-    }
-    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.
-        // However we don't have to worry about missing prop,
-        // because the decorator must have been applied to something.
-        die(1, this.annotationType_, `${adm.name_}.${key.toString()}`)
-    }
+function make_(
+    adm: ObservableObjectAdministration,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor
+): MakeResult {
+    return this.extend_(adm, key, descriptor, false) === null ? MakeResult.Cancel : MakeResult.Break
 }
 
 function extend_(

package/src/types/dynamicobject.ts

@@ -64,7 +64,7 @@ const objectProxyTraps: ProxyHandler<any> = {
     ownKeys(target: IIsObservableObject): PropertyKey[] {
         if (__DEV__ && globalState.trackingDerivation)
             warnAboutProxyRequirement(
-                "iterate keys to detect added / removed properties. Use `keys` from 'mobx' instead."
+                "iterate keys to detect added / removed properties. Use 'keys' from 'mobx' instead."
             )
         return getAdm(target).ownKeys_()
     },

package/src/types/flowannotation.ts

@@ -2,15 +2,12 @@ import {
     ObservableObjectAdministration,
     Annotation,
     defineProperty,
-    getDescriptor,
-    objectPrototype,
     die,
     flow,
     isFlow,
-    recordAnnotationApplied,
     isFunction,
     globalState,
-    storedAnnotationsSymbol
+    MakeResult
 } from "../internal"
 
 export function createFlowAnnotation(name: string, options?: object): Annotation {
@@ -22,44 +19,31 @@ export function createFlowAnnotation(name: string, options?: object): Annotation
     }
 }
 
-function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
-    let annotated = false
-    let source = adm.target_
-    while (source && source !== objectPrototype) {
-        const descriptor = getDescriptor(source, key)
-        if (descriptor) {
-            if (source !== adm.target_) {
-                // Prototype
-                if (isFlow(descriptor.value)) {
-                    // A prototype could have been annotated already by other constructor,
-                    // rest of the proto chain must be annotated already
-                    annotated = true
-                    break
-                }
-                const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, false)
-                defineProperty(source, key, flowDescriptor)
-            } else {
-                const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor)
-                const definePropertyOutcome = adm.defineProperty_(key, flowDescriptor)
-                if (!definePropertyOutcome) {
-                    // Intercepted
-                    return
-                }
-            }
-            annotated = true
-        }
-        source = Object.getPrototypeOf(source)
+function make_(
+    adm: ObservableObjectAdministration,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor,
+    source: object
+): MakeResult {
+    // own
+    if (source === adm.target_) {
+        return this.extend_(adm, key, descriptor, false) === null
+            ? MakeResult.Cancel
+            : MakeResult.Continue
     }
-    if (annotated) {
-        recordAnnotationApplied(adm, this, key)
-    } 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.
-        // However we don't have to worry about missing prop,
-        // because the decorator must have been applied to something.
-        die(1, this.annotationType_, `${adm.name_}.${key.toString()}`)
+    // prototype
+    // bound - must annotate protos to support super.flow()
+    if (this.options_?.bound && !isFlow(adm.target_[key])) {
+        if (this.extend_(adm, key, descriptor, false) === null) return MakeResult.Cancel
     }
+    if (isFlow(descriptor.value)) {
+        // A prototype could have been annotated already by other constructor,
+        // rest of the proto chain must be annotated already
+        return MakeResult.Break
+    }
+    const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, false, false)
+    defineProperty(source, key, flowDescriptor)
+    return MakeResult.Continue
 }
 
 function extend_(
@@ -68,7 +52,7 @@ function extend_(
     descriptor: PropertyDescriptor,
     proxyTrap: boolean
 ): boolean | null {
-    const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor)
+    const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, this.options_?.bound)
     return adm.defineProperty_(key, flowDescriptor, proxyTrap)
 }
 
@@ -91,12 +75,17 @@ function createFlowDescriptor(
     annotation: Annotation,
     key: PropertyKey,
     descriptor: PropertyDescriptor,
+    bound: boolean,
     // provides ability to disable safeDescriptors for prototypes
     safeDescriptors: boolean = globalState.safeDescriptors
 ): PropertyDescriptor {
     assertFlowDescriptor(adm, annotation, key, descriptor)
+    let { value } = descriptor
+    if (bound) {
+        value = value.bind(adm.proxy_ ?? adm.target_)
+    }
     return {
-        value: flow(descriptor.value),
+        value: flow(value),
         // Non-configurable for classes
         // prevents accidental field redefinition in subclass
         configurable: safeDescriptors ? adm.isPlainObject_ : true,

package/src/types/modifiers.ts

@@ -9,7 +9,12 @@ import {
     isObservableObject,
     isPlainObject,
     observable,
-    die
+    die,
+    isAction,
+    autoAction,
+    flow,
+    isFlow,
+    isGenerator
 } from "../internal"
 
 export interface IEnhancer<T> {
@@ -25,7 +30,13 @@ export function deepEnhancer(v, _, name) {
     if (isPlainObject(v)) return observable.object(v, undefined, { name })
     if (isES6Map(v)) return observable.map(v, { name })
     if (isES6Set(v)) return observable.set(v, { name })
-
+    if (typeof v === "function" && !isAction(v) && !isFlow(v)) {
+        if (isGenerator(v)) {
+            return flow(v)
+        } else {
+            return autoAction(name, v)
+        }
+    }
     return v
 }
 

package/src/types/observableannotation.ts

@@ -1,12 +1,9 @@
 import {
     ObservableObjectAdministration,
-    getDescriptor,
     deepEnhancer,
     die,
     Annotation,
-    recordAnnotationApplied,
-    objectPrototype,
-    storedAnnotationsSymbol
+    MakeResult
 } from "../internal"
 
 export function createObservableAnnotation(name: string, options?: object): Annotation {
@@ -18,36 +15,12 @@ export function createObservableAnnotation(name: string, options?: object): Anno
     }
 }
 
-function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
-    let source = adm.target_
-    // Copy props from proto as well, see test:
-    // "decorate should work with Object.create"
-    while (source && source !== objectPrototype) {
-        const descriptor = getDescriptor(source, key)
-        if (descriptor) {
-            assertObservableDescriptor(adm, this, key, descriptor)
-            const definePropertyOutcome = adm.defineObservableProperty_(
-                key,
-                descriptor.value,
-                this.options_?.enhancer ?? deepEnhancer
-            )
-            if (!definePropertyOutcome) {
-                // Intercepted
-                return
-            }
-            recordAnnotationApplied(adm, this, key)
-            return
-        }
-        source = Object.getPrototypeOf(source)
-    }
-    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.
-        // However we don't have to worry about missing prop,
-        // because the decorator must have been applied to something.
-        die(1, this.annotationType_, `${adm.name_}.${key.toString()}`)
-    }
+function make_(
+    adm: ObservableObjectAdministration,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor
+): MakeResult {
+    return this.extend_(adm, key, descriptor, false) === null ? MakeResult.Cancel : MakeResult.Break
 }
 
 function extend_(

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> = {
@@ -105,9 +102,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 +110,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_ = {}
@@ -184,7 +176,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 +228,45 @@ 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 +277,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 +290,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
@@ -673,8 +645,7 @@ export function asObservableObject(
         target,
         new Map(),
         String(name),
-        getAnnotationFromOptions(options),
-        options?.autoBind
+        getAnnotationFromOptions(options)
     )
 
     addHiddenProp(target, $mobx, adm)

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 {