mobx 6.1.8 → 6.3.2

package/dist/mobx.cjs.development.js

@@ -7,6 +7,18 @@ var niceErrors = {
   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",
@@ -63,7 +75,9 @@ var niceErrors = {
   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) {
@@ -526,6 +540,15 @@ function deepEnhancer(v, _, name) {
   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) {
@@ -579,6 +602,10 @@ function make_(adm, key) {
   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) {
@@ -594,65 +621,41 @@ function createActionAnnotation(name, options) {
   };
 }
 
-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) {
@@ -708,58 +711,45 @@ function createFlowAnnotation(name, options) {
   };
 }
 
-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);
 }
 
@@ -772,15 +762,23 @@ function assertFlowDescriptor(adm, _ref, key, _ref2) {
   }
 }
 
-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,
@@ -801,41 +799,12 @@ function createComputedAnnotation(name, options) {
   };
 }
 
-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) {
@@ -864,56 +833,130 @@ function createObservableAnnotation(name, options) {
   };
 }
 
-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
@@ -943,7 +986,9 @@ function getEnhancerFromOptions(options) {
   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_;
@@ -2127,8 +2172,16 @@ function propagateChangeConfirmed(observable) {
   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.
 
@@ -2139,11 +2192,6 @@ function propagateMaybeChanged(observable) {
   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");
@@ -2773,6 +2821,9 @@ function isFlowCancellationError(error) {
   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)) {
@@ -2858,6 +2909,7 @@ var flow = /*#__PURE__*/Object.assign(function flow(arg1, arg2) {
   res.isMobXFlow = true;
   return res;
 }, flowAnnotation);
+flow.bound = /*#__PURE__*/createDecoratorAnnotation(flowBoundAnnotation);
 
 function cancelPromise(promise) {
   if (isFunction(promise.cancel)) promise.cancel();
@@ -3082,6 +3134,20 @@ function get(obj, key) {
 
   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);
@@ -3102,7 +3168,7 @@ function cache(map, key, value) {
 
 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);
@@ -3134,12 +3200,12 @@ function toJSHelper(source, __alreadySeen) {
     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;
   }
@@ -3309,7 +3375,7 @@ var objectProxyTraps = {
     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) {
@@ -3396,57 +3462,39 @@ function makeObservable(target, annotations, options) {
   }
 
   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();
   }
@@ -4652,30 +4700,23 @@ var ObservableSet = /*#__PURE__*/function () {
 
 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;
@@ -4687,7 +4728,6 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
     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_);
@@ -4696,10 +4736,6 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
       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_ = {};
@@ -4768,7 +4804,7 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
   /**
    * @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
    */
@@ -4823,13 +4859,13 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
   }
   /**
    * @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) {
@@ -4837,12 +4873,46 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
     }
 
     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
    */
@@ -4854,7 +4924,7 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
     }
 
     if (annotation === true) {
-      annotation = inferAnnotationFromDescriptor(descriptor, this.defaultAnnotation_, this.autoBind_);
+      annotation = this.defaultAnnotation_;
     }
 
     if (annotation === false) {
@@ -4869,46 +4939,6 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
     }
 
     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
@@ -5013,11 +5043,10 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
         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();
     }
@@ -5115,13 +5144,11 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
       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;
@@ -5142,15 +5169,15 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
       } // 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
 
 
@@ -5254,7 +5281,7 @@ function asObservableObject(target, options) {
 
   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;
 }
@@ -5688,24 +5715,6 @@ function getSelf() {
   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_)
@@ -5771,6 +5780,7 @@ exports.comparer = comparer;
 exports.computed = computed;
 exports.configure = configure;
 exports.createAtom = createAtom;
+exports.defineProperty = apiDefineProperty;
 exports.entries = entries;
 exports.extendObservable = extendObservable;
 exports.flow = flow;
@@ -5786,6 +5796,7 @@ exports.isAction = isAction;
 exports.isBoxedObservable = isObservableValue;
 exports.isComputed = isComputed;
 exports.isComputedProp = isComputedProp;
+exports.isFlow = isFlow;
 exports.isFlowCancellationError = isFlowCancellationError;
 exports.isObservable = isObservable;
 exports.isObservableArray = isObservableArray;
@@ -5802,6 +5813,7 @@ exports.onBecomeObserved = onBecomeObserved;
 exports.onBecomeUnobserved = onBecomeUnobserved;
 exports.onReactionError = onReactionError;
 exports.override = override;
+exports.ownKeys = apiOwnKeys;
 exports.reaction = reaction;
 exports.remove = remove;
 exports.runInAction = runInAction;