mobx 6.1.8 → 6.3.2

package/dist/mobx.umd.development.js

@@ -9,6 +9,18 @@
       1: function _(annotationType, key) {
         return "Cannot apply '" + annotationType + "' to '" + key.toString() + "': Field not found.";
       },
+
+      /*
+      2(prop) {
+          return `invalid decorator for '${prop.toString()}'`
+      },
+      3(prop) {
+          return `Cannot decorate '${prop.toString()}': action can only be used on properties with a function value.`
+      },
+      4(prop) {
+          return `Cannot decorate '${prop.toString()}': computed can only be used on getter properties.`
+      },
+      */
       5: "'keys()' can only be used on observable objects, arrays, sets and maps",
       6: "'values()' can only be used on observable objects, arrays, sets and maps",
       7: "'entries()' can only be used on observable objects, arrays and maps",
@@ -65,7 +77,9 @@
       36: "isolateGlobalState should be called before MobX is running any reactions",
       37: function _(method) {
         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"
     };
     var errors =  niceErrors ;
     function die(error) {
@@ -528,6 +542,15 @@
       if (isES6Set(v)) return observable.set(v, {
         name: name
       });
+
+      if (typeof v === "function" && !isAction(v) && !isFlow(v)) {
+        if (isGenerator(v)) {
+          return flow(v);
+        } else {
+          return autoAction(name, v);
+        }
+      }
+
       return v;
     }
     function shallowEnhancer(v, _, name) {
@@ -581,6 +604,10 @@
       if ( !hasProp(adm.appliedAnnotations_, key)) {
         die("'" + adm.name_ + "." + key.toString() + "' is annotated with '" + this.annotationType_ + "', " + "but no such annotated member was found on prototype.");
       }
+
+      return 0
+      /* Cancel */
+      ;
     }
 
     function extend_(adm, key, descriptor, proxyTrap) {
@@ -596,65 +623,41 @@
       };
     }
 
-    function make_$1(adm, key) {
-      var _this$options_$bound, _this$options_, _adm$target_$storedAn;
+    function make_$1(adm, key, descriptor, source) {
+      var _this$options_;
 
-      var annotated = false;
-      var source = adm.target_;
-      var bound = (_this$options_$bound = (_this$options_ = this.options_) == null ? void 0 : _this$options_.bound) != null ? _this$options_$bound : false;
+      // bound
+      if ((_this$options_ = this.options_) == null ? void 0 : _this$options_.bound) {
+        return this.extend_(adm, key, descriptor, false) === null ? 0
+        /* Cancel */
+        : 1
+        /* Break */
+        ;
+      } // own
 
-      while (source && source !== objectPrototype) {
-        var descriptor = getDescriptor(source, key);
 
-        if (descriptor) {
-          // Instance or bound
-          // Keep first because the operation can be intercepted
-          // and we don't want to end up with partially annotated proto chain
-          if (source === adm.target_ || bound) {
-            var actionDescriptor = createActionDescriptor(adm, this, key, descriptor);
-            var definePropertyOutcome = adm.defineProperty_(key, actionDescriptor);
+      if (source === adm.target_) {
+        return this.extend_(adm, key, descriptor, false) === null ? 0
+        /* Cancel */
+        : 2
+        /* Continue */
+        ;
+      } // prototype
 
-            if (!definePropertyOutcome) {
-              // Intercepted
-              return;
-            }
-
-            annotated = true; // Don't annotate protos if bound
-
-            if (bound) {
-              break;
-            }
-          } // Prototype
-
-
-          if (source !== adm.target_) {
-            if (isAction(descriptor.value)) {
-              // A prototype could have been annotated already by other constructor,
-              // rest of the proto chain must be annotated already
-              annotated = true;
-              break;
-            }
-
-            var _actionDescriptor = createActionDescriptor(adm, this, key, descriptor, false);
-
-            defineProperty(source, key, _actionDescriptor);
-            annotated = true;
-          }
-        }
 
-        source = Object.getPrototypeOf(source);
+      if (isAction(descriptor.value)) {
+        // A prototype could have been annotated already by other constructor,
+        // rest of the proto chain must be annotated already
+        return 1
+        /* Break */
+        ;
       }
 
-      if (annotated) {
-        recordAnnotationApplied(adm, this, key);
-      } else if (!((_adm$target_$storedAn = adm.target_[storedAnnotationsSymbol]) == null ? void 0 : _adm$target_$storedAn[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());
-      }
+      var actionDescriptor = createActionDescriptor(adm, this, key, descriptor, false);
+      defineProperty(source, key, actionDescriptor);
+      return 2
+      /* Continue */
+      ;
     }
 
     function extend_$1(adm, key, descriptor, proxyTrap) {
@@ -710,58 +713,45 @@
       };
     }
 
-    function make_$2(adm, key) {
-      var _adm$target_$storedAn;
-
-      var annotated = false;
-      var source = adm.target_;
-
-      while (source && source !== objectPrototype) {
-        var 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;
-            }
-
-            var flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, false);
-            defineProperty(source, key, flowDescriptor);
-          } else {
-            var _flowDescriptor = createFlowDescriptor(adm, this, key, descriptor);
-
-            var definePropertyOutcome = adm.defineProperty_(key, _flowDescriptor);
+    function make_$2(adm, key, descriptor, source) {
+      var _this$options_;
 
-            if (!definePropertyOutcome) {
-              // Intercepted
-              return;
-            }
-          }
+      // own
+      if (source === adm.target_) {
+        return this.extend_(adm, key, descriptor, false) === null ? 0
+        /* Cancel */
+        : 2
+        /* Continue */
+        ;
+      } // prototype
+      // bound - must annotate protos to support super.flow()
 
-          annotated = true;
-        }
 
-        source = Object.getPrototypeOf(source);
+      if (((_this$options_ = this.options_) == null ? void 0 : _this$options_.bound) && !isFlow(adm.target_[key])) {
+        if (this.extend_(adm, key, descriptor, false) === null) return 0
+        /* Cancel */
+        ;
       }
 
-      if (annotated) {
-        recordAnnotationApplied(adm, this, key);
-      } else if (!((_adm$target_$storedAn = adm.target_[storedAnnotationsSymbol]) == null ? void 0 : _adm$target_$storedAn[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());
+      if (isFlow(descriptor.value)) {
+        // A prototype could have been annotated already by other constructor,
+        // rest of the proto chain must be annotated already
+        return 1
+        /* Break */
+        ;
       }
+
+      var flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, false, false);
+      defineProperty(source, key, flowDescriptor);
+      return 2
+      /* Continue */
+      ;
     }
 
     function extend_$2(adm, key, descriptor, proxyTrap) {
-      var flowDescriptor = createFlowDescriptor(adm, this, key, descriptor);
+      var _this$options_2;
+
+      var flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, (_this$options_2 = this.options_) == null ? void 0 : _this$options_2.bound);
       return adm.defineProperty_(key, flowDescriptor, proxyTrap);
     }
 
@@ -774,15 +764,23 @@
       }
     }
 
-    function createFlowDescriptor(adm, annotation, key, descriptor, // provides ability to disable safeDescriptors for prototypes
+    function createFlowDescriptor(adm, annotation, key, descriptor, bound, // provides ability to disable safeDescriptors for prototypes
     safeDescriptors) {
       if (safeDescriptors === void 0) {
         safeDescriptors = globalState.safeDescriptors;
       }
 
       assertFlowDescriptor(adm, annotation, key, descriptor);
+      var value = descriptor.value;
+
+      if (bound) {
+        var _adm$proxy_;
+
+        value = value.bind((_adm$proxy_ = adm.proxy_) != null ? _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,
@@ -803,41 +801,12 @@
       };
     }
 
-    function make_$3(adm, key) {
-      var _adm$target_$storedAn;
-
-      var source = adm.target_;
-
-      while (source && source !== objectPrototype) {
-        var descriptor = getDescriptor(source, key);
-
-        if (descriptor) {
-          assertComputedDescriptor(adm, this, key, descriptor);
-          var definePropertyOutcome = adm.defineComputedProperty_(key, _extends({}, this.options_, {
-            get: descriptor.get,
-            set: descriptor.set
-          }));
-
-          if (!definePropertyOutcome) {
-            // Intercepted
-            return;
-          }
-
-          recordAnnotationApplied(adm, this, key);
-          return;
-        }
-
-        source = Object.getPrototypeOf(source);
-      }
-
-      if (!((_adm$target_$storedAn = adm.target_[storedAnnotationsSymbol]) == null ? void 0 : _adm$target_$storedAn[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_$3(adm, key, descriptor) {
+      return this.extend_(adm, key, descriptor, false) === null ? 0
+      /* Cancel */
+      : 1
+      /* Break */
+      ;
     }
 
     function extend_$3(adm, key, descriptor, proxyTrap) {
@@ -866,56 +835,130 @@
       };
     }
 
-    function make_$4(adm, key) {
-      var _adm$target_$storedAn;
+    function make_$4(adm, key, descriptor) {
+      return this.extend_(adm, key, descriptor, false) === null ? 0
+      /* Cancel */
+      : 1
+      /* Break */
+      ;
+    }
 
-      var source = adm.target_; // Copy props from proto as well, see test:
-      // "decorate should work with Object.create"
+    function extend_$4(adm, key, descriptor, proxyTrap) {
+      var _this$options_$enhanc, _this$options_;
+
+      assertObservableDescriptor(adm, this, key, descriptor);
+      return adm.defineObservableProperty_(key, descriptor.value, (_this$options_$enhanc = (_this$options_ = this.options_) == null ? void 0 : _this$options_.enhancer) != null ? _this$options_$enhanc : deepEnhancer, proxyTrap);
+    }
+
+    function assertObservableDescriptor(adm, _ref, key, descriptor) {
+      var annotationType_ = _ref.annotationType_;
+
+      if ( !("value" in descriptor)) {
+        die("Cannot apply '" + annotationType_ + "' to '" + adm.name_ + "." + key.toString() + "':" + ("\n'" + annotationType_ + "' cannot be used on getter/setter properties"));
+      }
+    }
 
-      while (source && source !== objectPrototype) {
-        var descriptor = getDescriptor(source, key);
+    var AUTO = "true";
+    var autoAnnotation = /*#__PURE__*/createAutoAnnotation();
+    function createAutoAnnotation(options) {
+      return {
+        annotationType_: AUTO,
+        options_: options,
+        make_: make_$5,
+        extend_: extend_$5
+      };
+    }
 
-        if (descriptor) {
-          var _this$options_$enhanc, _this$options_;
+    function make_$5(adm, key, descriptor, source) {
+      var _this$options_3, _this$options_4;
 
-          assertObservableDescriptor(adm, this, key, descriptor);
-          var definePropertyOutcome = adm.defineObservableProperty_(key, descriptor.value, (_this$options_$enhanc = (_this$options_ = this.options_) == null ? void 0 : _this$options_.enhancer) != null ? _this$options_$enhanc : deepEnhancer);
+      // getter -> computed
+      if (descriptor.get) {
+        return computed.make_(adm, key, descriptor, source);
+      } // lone setter -> action setter
 
-          if (!definePropertyOutcome) {
-            // Intercepted
-            return;
-          }
 
-          recordAnnotationApplied(adm, this, key);
-          return;
+      if (descriptor.set) {
+        // TODO make action applicable to setter and delegate to action.make_
+        var set = createAction(key.toString(), descriptor.set); // own
+
+        if (source === adm.target_) {
+          return adm.defineProperty_(key, {
+            configurable: globalState.safeDescriptors ? adm.isPlainObject_ : true,
+            set: set
+          }) === null ? 0
+          /* Cancel */
+          : 2
+          /* Continue */
+          ;
+        } // proto
+
+
+        defineProperty(source, key, {
+          configurable: true,
+          set: set
+        });
+        return 2
+        /* Continue */
+        ;
+      } // function on proto -> autoAction/flow
+
+
+      if (source !== adm.target_ && typeof descriptor.value === "function") {
+        var _this$options_2;
+
+        if (isGenerator(descriptor.value)) {
+          var _this$options_;
+
+          var flowAnnotation = ((_this$options_ = this.options_) == null ? void 0 : _this$options_.autoBind) ? flow.bound : flow;
+          return flowAnnotation.make_(adm, key, descriptor, source);
         }
 
-        source = Object.getPrototypeOf(source);
-      }
+        var actionAnnotation = ((_this$options_2 = this.options_) == null ? void 0 : _this$options_2.autoBind) ? autoAction.bound : autoAction;
+        return actionAnnotation.make_(adm, key, descriptor, source);
+      } // other -> observable
+      // Copy props from proto as well, see test:
+      // "decorate should work with Object.create"
+
+
+      var observableAnnotation = ((_this$options_3 = this.options_) == null ? void 0 : _this$options_3.deep) === false ? observable.ref : observable; // if function respect autoBind option
 
-      if (!((_adm$target_$storedAn = adm.target_[storedAnnotationsSymbol]) == null ? void 0 : _adm$target_$storedAn[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());
+      if (typeof descriptor.value === "function" && ((_this$options_4 = this.options_) == null ? void 0 : _this$options_4.autoBind)) {
+        var _adm$proxy_;
+
+        descriptor.value = descriptor.value.bind((_adm$proxy_ = adm.proxy_) != null ? _adm$proxy_ : adm.target_);
       }
+
+      return observableAnnotation.make_(adm, key, descriptor, source);
     }
 
-    function extend_$4(adm, key, descriptor, proxyTrap) {
-      var _this$options_$enhanc2, _this$options_2;
+    function extend_$5(adm, key, descriptor, proxyTrap) {
+      var _this$options_5, _this$options_6;
 
-      assertObservableDescriptor(adm, this, key, descriptor);
-      return adm.defineObservableProperty_(key, descriptor.value, (_this$options_$enhanc2 = (_this$options_2 = this.options_) == null ? void 0 : _this$options_2.enhancer) != null ? _this$options_$enhanc2 : deepEnhancer, proxyTrap);
-    }
+      // getter -> computed
+      if (descriptor.get) {
+        return computed.extend_(adm, key, descriptor, proxyTrap);
+      } // lone setter -> action setter
 
-    function assertObservableDescriptor(adm, _ref, key, descriptor) {
-      var annotationType_ = _ref.annotationType_;
 
-      if ( !("value" in descriptor)) {
-        die("Cannot apply '" + annotationType_ + "' to '" + adm.name_ + "." + key.toString() + "':" + ("\n'" + annotationType_ + "' cannot be used on getter/setter properties"));
+      if (descriptor.set) {
+        // TODO make action applicable to setter and delegate to action.extend_
+        return adm.defineProperty_(key, {
+          configurable: globalState.safeDescriptors ? adm.isPlainObject_ : true,
+          set: createAction(key.toString(), descriptor.set)
+        }, proxyTrap);
+      } // other -> observable
+      // if function respect autoBind option
+
+
+      if (typeof descriptor.value === "function" && ((_this$options_5 = this.options_) == null ? void 0 : _this$options_5.autoBind)) {
+        var _adm$proxy_2;
+
+        descriptor.value = descriptor.value.bind((_adm$proxy_2 = adm.proxy_) != null ? _adm$proxy_2 : adm.target_);
       }
+
+      var observableAnnotation = ((_this$options_6 = this.options_) == null ? void 0 : _this$options_6.deep) === false ? observable.ref : observable;
+      return observableAnnotation.extend_(adm, key, descriptor, proxyTrap);
     }
 
     // in the majority of cases
@@ -945,7 +988,9 @@
       return options.deep === true ? deepEnhancer : options.deep === false ? referenceEnhancer : getEnhancerFromAnnotation(options.defaultDecorator);
     }
     function getAnnotationFromOptions(options) {
-      return options ? options.deep === true ? observableAnnotation : options.deep === false ? observableRefAnnotation : options.defaultDecorator : undefined;
+      var _options$defaultDecor;
+
+      return options ? (_options$defaultDecor = options.defaultDecorator) != null ? _options$defaultDecor : createAutoAnnotation(options) : undefined;
     }
     function getEnhancerFromAnnotation(annotation) {
       var _annotation$options_$, _annotation$options_;
@@ -2129,8 +2174,16 @@
       if (observable.lowestObserverState_ === IDerivationState_.STALE_) return;
       observable.lowestObserverState_ = IDerivationState_.STALE_;
       observable.observers_.forEach(function (d) {
-        if (d.dependenciesState_ === IDerivationState_.POSSIBLY_STALE_) d.dependenciesState_ = IDerivationState_.STALE_;else if (d.dependenciesState_ === IDerivationState_.UP_TO_DATE_ // this happens during computing of `d`, just keep lowestObserverState up to date.
-        ) observable.lowestObserverState_ = IDerivationState_.UP_TO_DATE_;
+        if (d.dependenciesState_ === IDerivationState_.POSSIBLY_STALE_) {
+          d.dependenciesState_ = IDerivationState_.STALE_;
+
+          if ( 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.
+        ) {
+            observable.lowestObserverState_ = IDerivationState_.UP_TO_DATE_;
+          }
       }); // invariantLOS(observable, "confirmed end");
     } // Used by computed when its dependency changed, but we don't wan't to immediately recompute.
 
@@ -2141,11 +2194,6 @@
       observable.observers_.forEach(function (d) {
         if (d.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {
           d.dependenciesState_ = IDerivationState_.POSSIBLY_STALE_;
-
-          if ( d.isTracing_ !== TraceMode.NONE) {
-            logTraceInfo(d, observable);
-          }
-
           d.onBecomeStale_();
         }
       }); // invariantLOS(observable, "maybe end");
@@ -2775,6 +2823,9 @@
       return error instanceof FlowCancellationError;
     }
     var flowAnnotation = /*#__PURE__*/createFlowAnnotation("flow");
+    var flowBoundAnnotation = /*#__PURE__*/createFlowAnnotation("flow.bound", {
+      bound: true
+    });
     var flow = /*#__PURE__*/Object.assign(function flow(arg1, arg2) {
       // @flow
       if (isStringish(arg2)) {
@@ -2860,6 +2911,7 @@
       res.isMobXFlow = true;
       return res;
     }, flowAnnotation);
+    flow.bound = /*#__PURE__*/createDecoratorAnnotation(flowBoundAnnotation);
 
     function cancelPromise(promise) {
       if (isFunction(promise.cancel)) promise.cancel();
@@ -3084,6 +3136,20 @@
 
       die(11);
     }
+    function apiDefineProperty(obj, key, descriptor) {
+      if (isObservableObject(obj)) {
+        return obj[$mobx].defineProperty_(key, descriptor);
+      }
+
+      die(39);
+    }
+    function apiOwnKeys(obj) {
+      if (isObservableObject(obj)) {
+        return obj[$mobx].ownKeys_();
+      }
+
+      die(38);
+    }
 
     function observe(thing, propOrCb, cbOrFire, fireImmediately) {
       if (isFunction(cbOrFire)) return observeObservableProperty(thing, propOrCb, cbOrFire, fireImmediately);else return observeObservable(thing, propOrCb, cbOrFire);
@@ -3104,7 +3170,7 @@
 
     function toJSHelper(source, __alreadySeen) {
       if (source == null || typeof source !== "object" || source instanceof Date || !isObservable(source)) return source;
-      if (isObservableValue(source)) return toJSHelper(source.get(), __alreadySeen);
+      if (isObservableValue(source) || isComputedValue(source)) return toJSHelper(source.get(), __alreadySeen);
 
       if (__alreadySeen.has(source)) {
         return __alreadySeen.get(source);
@@ -3136,12 +3202,12 @@
         return _res2;
       } else {
         // must be observable object
-        keys(source); // make sure keys are observed
-
         var _res3 = cache(__alreadySeen, source, {});
 
-        getPlainObjectKeys(source).forEach(function (key) {
-          _res3[key] = toJSHelper(source[key], __alreadySeen);
+        apiOwnKeys(source).forEach(function (key) {
+          if (objectPrototype.propertyIsEnumerable.call(source, key)) {
+            _res3[key] = toJSHelper(source[key], __alreadySeen);
+          }
         });
         return _res3;
       }
@@ -3311,7 +3377,7 @@
         return (_getAdm$definePropert = getAdm(target).defineProperty_(name, descriptor)) != null ? _getAdm$definePropert : true;
       },
       ownKeys: function ownKeys(target) {
-        if ( globalState.trackingDerivation) warnAboutProxyRequirement("iterate keys to detect added / removed properties. Use `keys` from 'mobx' instead.");
+        if ( globalState.trackingDerivation) warnAboutProxyRequirement("iterate keys to detect added / removed properties. Use 'keys' from 'mobx' instead.");
         return getAdm(target).ownKeys_();
       },
       preventExtensions: function preventExtensions(target) {
@@ -3398,57 +3464,39 @@
       }
 
       return target;
-    }
+    } // proto[keysSymbol] = new Set<PropertyKey>()
+
+    var keysSymbol = /*#__PURE__*/Symbol("mobx-keys");
     function makeAutoObservable(target, overrides, options) {
       {
         if (!isPlainObject(target) && !isPlainObject(Object.getPrototypeOf(target))) die("'makeAutoObservable' can only be used for classes that don't have a superclass");
         if (isObservableObject(target)) die("makeAutoObservable can only be used on objects not already made observable");
-      } // Optimization (avoids visiting protos)
-      // assumes that annotation.make_/.extend_ works the same for plain objects
+      } // Optimization: avoid visiting protos
+      // Assumes that annotation.make_/.extend_ works the same for plain objects
 
 
       if (isPlainObject(target)) {
         return extendObservable(target, target, overrides, options);
       }
 
-      var adm = asObservableObject(target, options)[$mobx];
-      startBatch();
-
-      try {
-        // Use cached inferred annotations if available (only in classes)
-        if (target[inferredAnnotationsSymbol]) {
-          target[inferredAnnotationsSymbol].forEach(function (value, key) {
-            return adm.make_(key, value);
-          }); // Overrides are not cached, unless `true`, see #2832
-
-          if (overrides) {
-            ownKeys(overrides).forEach(function (key) {
-              var annotation = overrides[key];
-
-              if (annotation !== true) {
-                adm.make_(key, annotation);
-              }
-            });
-          }
-        } else {
-          var _ignoreKeys;
-
-          var ignoreKeys = (_ignoreKeys = {}, _ignoreKeys[$mobx] = 1, _ignoreKeys[inferredAnnotationsSymbol] = 1, _ignoreKeys.constructor = 1, _ignoreKeys);
+      var adm = asObservableObject(target, options)[$mobx]; // Optimization: cache keys on proto
+      // Assumes makeAutoObservable can be called only once per object and can't be used in subclass
 
-          var make = function make(key) {
-            if (ignoreKeys[key]) return;
-            ignoreKeys[key] = 1;
-            adm.make_(key, // must pass "undefined" for { key: undefined }
-            !overrides ? true : key in overrides ? overrides[key] : true);
-          };
+      if (!target[keysSymbol]) {
+        var proto = Object.getPrototypeOf(target);
+        var keys = new Set([].concat(ownKeys(target), ownKeys(proto)));
+        keys["delete"]("constructor");
+        keys["delete"]($mobx);
+        addHiddenProp(proto, keysSymbol, keys);
+      }
 
-          var current = target;
+      startBatch();
 
-          while (current && current !== objectPrototype) {
-            ownKeys(current).forEach(make);
-            current = Object.getPrototypeOf(current);
-          }
-        }
+      try {
+        target[keysSymbol].forEach(function (key) {
+          return adm.make_(key, // must pass "undefined" for { key: undefined }
+          !overrides ? true : key in overrides ? overrides[key] : true);
+        });
       } finally {
         endBatch();
       }
@@ -4654,30 +4702,23 @@
 
     var isObservableSet = /*#__PURE__*/createInstanceofPredicate("ObservableSet", ObservableSet);
 
-    var inferredAnnotationsSymbol = /*#__PURE__*/Symbol("mobx-inferred-annotations");
     var descriptorCache = /*#__PURE__*/Object.create(null);
     var REMOVE = "remove";
     var ObservableObjectAdministration = /*#__PURE__*/function () {
       function ObservableObjectAdministration(target_, values_, name_, // Used anytime annotation is not explicitely provided
-      defaultAnnotation_, // Bind automatically inferred actions?
-      autoBind_) {
+      defaultAnnotation_) {
         if (values_ === void 0) {
           values_ = new Map();
         }
 
         if (defaultAnnotation_ === void 0) {
-          defaultAnnotation_ = observable;
-        }
-
-        if (autoBind_ === void 0) {
-          autoBind_ = false;
+          defaultAnnotation_ = autoAnnotation;
         }
 
         this.target_ = void 0;
         this.values_ = void 0;
         this.name_ = void 0;
         this.defaultAnnotation_ = void 0;
-        this.autoBind_ = void 0;
         this.keysAtom_ = void 0;
         this.changeListeners_ = void 0;
         this.interceptors_ = void 0;
@@ -4689,7 +4730,6 @@
         this.values_ = values_;
         this.name_ = name_;
         this.defaultAnnotation_ = defaultAnnotation_;
-        this.autoBind_ = autoBind_;
         this.keysAtom_ = new Atom( this.name_ + ".keys" ); // Optimization: we use this frequently
 
         this.isPlainObject_ = isPlainObject(this.target_);
@@ -4698,10 +4738,6 @@
           die("defaultAnnotation must be valid annotation");
         }
 
-        if ( typeof this.autoBind_ !== "boolean") {
-          die("autoBind must be boolean");
-        }
-
         {
           // Prepare structure for tracking which fields were already annotated
           this.appliedAnnotations_ = {};
@@ -4770,7 +4806,7 @@
       /**
        * @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
        */
@@ -4825,13 +4861,13 @@
       }
       /**
        * @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
        */
       ;
 
       _proto.make_ = function make_(key, annotation) {
         if (annotation === true) {
-          annotation = this.inferAnnotation_(key);
+          annotation = this.defaultAnnotation_;
         }
 
         if (annotation === false) {
@@ -4839,12 +4875,46 @@
         }
 
         assertAnnotable(this, annotation, key);
-        annotation.make_(this, key);
+
+        if (!(key in this.target_)) {
+          var _this$target_$storedA;
+
+          // 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_$storedA = this.target_[storedAnnotationsSymbol]) == null ? void 0 : _this$target_$storedA[key]) {
+            return; // will be annotated by subclass constructor
+          } else {
+            die(1, annotation.annotationType_, this.name_ + "." + key.toString());
+          }
+        }
+
+        var source = this.target_;
+
+        while (source && source !== objectPrototype) {
+          var descriptor = getDescriptor(source, key);
+
+          if (descriptor) {
+            var outcome = annotation.make_(this, key, descriptor, source);
+            if (outcome === 0
+            /* Cancel */
+            ) return;
+            if (outcome === 1
+            /* 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
        */
@@ -4856,7 +4926,7 @@
         }
 
         if (annotation === true) {
-          annotation = inferAnnotationFromDescriptor(descriptor, this.defaultAnnotation_, this.autoBind_);
+          annotation = this.defaultAnnotation_;
         }
 
         if (annotation === false) {
@@ -4871,46 +4941,6 @@
         }
 
         return outcome;
-      };
-
-      _proto.inferAnnotation_ = function inferAnnotation_(key) {
-        var _this$target_$inferre;
-
-        // Inherited is fine - annotation cannot differ in subclass
-        var annotation = (_this$target_$inferre = this.target_[inferredAnnotationsSymbol]) == null ? void 0 : _this$target_$inferre.get(key);
-        if (annotation) return annotation;
-        var current = this.target_;
-
-        while (current && current !== objectPrototype) {
-          var 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
-          var closestProto = Object.getPrototypeOf(this.target_);
-
-          if (!hasProp(closestProto, inferredAnnotationsSymbol)) {
-            addHiddenProp(closestProto, inferredAnnotationsSymbol, new Map());
-          }
-
-          closestProto[inferredAnnotationsSymbol].set(key, annotation);
-        }
-
-        return annotation;
       }
       /**
        * @param {PropertyKey} key
@@ -5015,11 +5045,10 @@
             defineProperty(this.target_, key, descriptor);
           }
 
-          var _observable = new ObservableValue(value, enhancer, "development" !== "production" ? this.name_ + "." + key.toString() : "ObservableObject.key", false);
-
-          this.values_.set(key, _observable); // Notify (value possibly changed by ObservableValue)
+          var observable = new ObservableValue(value, enhancer, "development" !== "production" ? this.name_ + "." + key.toString() : "ObservableObject.key", false);
+          this.values_.set(key, observable); // Notify (value possibly changed by ObservableValue)
 
-          this.notifyPropertyAddition_(key, _observable.value_);
+          this.notifyPropertyAddition_(key, observable.value_);
         } finally {
           endBatch();
         }
@@ -5117,13 +5146,11 @@
           startBatch();
           var notify = hasListeners(this);
           var notifySpy = "development" !== "production" && isSpyEnabled();
-
-          var _observable2 = this.values_.get(key); // Value needed for spies/listeners
-
+          var observable = this.values_.get(key); // Value needed for spies/listeners
 
           var value = undefined; // Optimization: don't pull the value unless we will need it
 
-          if (!_observable2 && (notify || notifySpy)) {
+          if (!observable && (notify || notifySpy)) {
             var _getDescriptor;
 
             value = (_getDescriptor = getDescriptor(this.target_, key)) == null ? void 0 : _getDescriptor.value;
@@ -5144,15 +5171,15 @@
           } // Clear observable
 
 
-          if (_observable2) {
+          if (observable) {
             this.values_["delete"](key); // for computed, value is undefined
 
-            if (_observable2 instanceof ObservableValue) {
-              value = _observable2.value_;
+            if (observable instanceof ObservableValue) {
+              value = observable.value_;
             } // Notify: autorun(() => obj[key]), see #1796
 
 
-            propagateChanged(_observable2);
+            propagateChanged(observable);
           } // Notify "keys/entries/values" observers
 
 
@@ -5256,7 +5283,7 @@
 
       if ( !Object.isExtensible(target)) die("Cannot make the designated object observable; it is not extensible");
       var name = (_options$name = options == null ? void 0 : options.name) != null ? _options$name :  (isPlainObject(target) ? "ObservableObject" : target.constructor.name) + "@" + getNextId() ;
-      var adm = new ObservableObjectAdministration(target, new Map(), String(name), getAnnotationFromOptions(options), options == null ? void 0 : options.autoBind);
+      var adm = new ObservableObjectAdministration(target, new Map(), String(name), getAnnotationFromOptions(options));
       addHiddenProp(target, $mobx, adm);
       return target;
     }
@@ -5690,24 +5717,6 @@
       return this;
     }
 
-    /**
-     * Infers the best fitting annotation from property descriptor or false if the field shoudn't be annotated
-     * - getter(+setter) -> computed
-     * - setter w/o getter -> false (ignore)
-     * - flow -> false (ignore)
-     * - generator -> flow
-     * - action -> false (ignore)
-     * - function -> action (optionally bound)
-     * - other -> defaultAnnotation
-     */
-
-    function inferAnnotationFromDescriptor(desc, defaultAnnotation, autoBind) {
-      if (desc.get) return computed;
-      if (desc.set) return false; // ignore lone setter
-      // If already wrapped in action/flow, don't do that another time, but assume it is already set up properly.
-
-      return isFunction(desc.value) ? isGenerator(desc.value) ? isFlow(desc.value) ? false : flow : isAction(desc.value) ? false : autoBind ? autoAction.bound : autoAction : defaultAnnotation;
-    }
     function isAnnotation(thing) {
       return (// Can be function
         thing instanceof Object && typeof thing.annotationType_ === "string" && isFunction(thing.make_) && isFunction(thing.extend_)
@@ -5773,6 +5782,7 @@
     exports.computed = computed;
     exports.configure = configure;
     exports.createAtom = createAtom;
+    exports.defineProperty = apiDefineProperty;
     exports.entries = entries;
     exports.extendObservable = extendObservable;
     exports.flow = flow;
@@ -5788,6 +5798,7 @@
     exports.isBoxedObservable = isObservableValue;
     exports.isComputed = isComputed;
     exports.isComputedProp = isComputedProp;
+    exports.isFlow = isFlow;
     exports.isFlowCancellationError = isFlowCancellationError;
     exports.isObservable = isObservable;
     exports.isObservableArray = isObservableArray;
@@ -5804,6 +5815,7 @@
     exports.onBecomeUnobserved = onBecomeUnobserved;
     exports.onReactionError = onReactionError;
     exports.override = override;
+    exports.ownKeys = apiOwnKeys;
     exports.reaction = reaction;
     exports.remove = remove;
     exports.runInAction = runInAction;