mobx 6.1.8 → 6.3.2

package/dist/mobx.esm.development.js

@@ -3,6 +3,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",
@@ -59,7 +71,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) {
@@ -522,6 +536,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) {
@@ -575,6 +598,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) {
@@ -590,65 +617,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) {
@@ -704,58 +707,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);
 }
 
@@ -768,15 +758,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,
@@ -797,41 +795,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) {
@@ -860,56 +829,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
@@ -939,7 +982,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_;
@@ -2123,8 +2168,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.
 
@@ -2135,11 +2188,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");
@@ -2769,6 +2817,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)) {
@@ -2854,6 +2905,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();
@@ -3078,6 +3130,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);
@@ -3098,7 +3164,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);
@@ -3130,12 +3196,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;
   }
@@ -3305,7 +3371,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) {
@@ -3392,57 +3458,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();
   }
@@ -4648,30 +4696,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;
@@ -4683,7 +4724,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_);
@@ -4692,10 +4732,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_ = {};
@@ -4764,7 +4800,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
    */
@@ -4819,13 +4855,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) {
@@ -4833,12 +4869,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
    */
@@ -4850,7 +4920,7 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
     }
 
     if (annotation === true) {
-      annotation = inferAnnotationFromDescriptor(descriptor, this.defaultAnnotation_, this.autoBind_);
+      annotation = this.defaultAnnotation_;
     }
 
     if (annotation === false) {
@@ -4865,46 +4935,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
@@ -5009,11 +5039,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();
     }
@@ -5111,13 +5140,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;
@@ -5138,15 +5165,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
 
 
@@ -5250,7 +5277,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;
 }
@@ -5684,24 +5711,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_)
@@ -5744,5 +5753,5 @@ if (typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === "object") {
   });
 }
 
-export { $mobx, FlowCancellationError, ObservableMap, ObservableSet, Reaction, allowStateChanges as _allowStateChanges, runInAction as _allowStateChangesInsideComputed, allowStateReadsEnd as _allowStateReadsEnd, allowStateReadsStart as _allowStateReadsStart, autoAction as _autoAction, _endAction, getAdministration as _getAdministration, getGlobalState as _getGlobalState, interceptReads as _interceptReads, isComputingDerivation as _isComputingDerivation, resetGlobalState as _resetGlobalState, _startAction, action, autorun, comparer, computed, configure, createAtom, entries, extendObservable, flow, flowResult, get, getAtom, getDebugName, getDependencyTree, getObserverTree, has, intercept, isAction, isObservableValue as isBoxedObservable, isComputed, isComputedProp, isFlowCancellationError, isObservable, isObservableArray, isObservableMap, isObservableObject, isObservableProp, isObservableSet, keys, makeAutoObservable, makeObservable, observable, observe, onBecomeObserved, onBecomeUnobserved, onReactionError, override, reaction, remove, runInAction, set, spy, toJS, trace, transaction, untracked, values, when };
+export { $mobx, FlowCancellationError, ObservableMap, ObservableSet, Reaction, allowStateChanges as _allowStateChanges, runInAction as _allowStateChangesInsideComputed, allowStateReadsEnd as _allowStateReadsEnd, allowStateReadsStart as _allowStateReadsStart, autoAction as _autoAction, _endAction, getAdministration as _getAdministration, getGlobalState as _getGlobalState, interceptReads as _interceptReads, isComputingDerivation as _isComputingDerivation, resetGlobalState as _resetGlobalState, _startAction, action, autorun, comparer, computed, configure, createAtom, apiDefineProperty as defineProperty, entries, extendObservable, flow, flowResult, get, getAtom, getDebugName, getDependencyTree, getObserverTree, has, intercept, isAction, isObservableValue as isBoxedObservable, isComputed, isComputedProp, isFlow, isFlowCancellationError, isObservable, isObservableArray, isObservableMap, isObservableObject, isObservableProp, isObservableSet, keys, makeAutoObservable, makeObservable, observable, observe, onBecomeObserved, onBecomeUnobserved, onReactionError, override, apiOwnKeys as ownKeys, reaction, remove, runInAction, set, spy, toJS, trace, transaction, untracked, values, when };
 //# sourceMappingURL=mobx.esm.development.js.map