mobx 7.0.4 → 7.0.6

package/dist/mobx.esm.development.js

@@ -816,6 +816,19 @@ function createAutoAnnotation(options) {
     extend_
   };
 }
+// The auto annotation only depends on `deep` and `autoBind`, so share one instance per combination
+// instead of allocating one for every object created with options
+const autoAnnotations = [autoAnnotation];
+function getAutoAnnotation(options) {
+  var _autoAnnotations$idx;
+  const deep = options.deep !== false;
+  const autoBind = !!options.autoBind;
+  const idx = (deep ? 0 : 1) | (autoBind ? 2 : 0);
+  return (_autoAnnotations$idx = autoAnnotations[idx]) != null ? _autoAnnotations$idx : autoAnnotations[idx] = createAutoAnnotation({
+    deep,
+    autoBind
+  });
+}
 function make_$1(adm, key, descriptor, source) {
   var _this$options_3, _this$options_4;
   // getter -> computed
@@ -932,7 +945,7 @@ function getEnhancerFromOptions(options) {
 }
 function getAnnotationFromOptions(options) {
   var _options$defaultDecor;
-  return options ? (_options$defaultDecor = options.defaultDecorator) != null ? _options$defaultDecor : createAutoAnnotation(options) : undefined;
+  return options ? (_options$defaultDecor = options.defaultDecorator) != null ? _options$defaultDecor : getAutoAnnotation(options) : undefined;
 }
 function getEnhancerFromAnnotation(annotation) {
   var _annotation$options_$, _annotation$options_;
@@ -1178,14 +1191,13 @@ class ObservableValue extends Atom {
     this.equals_ = equals_;
     this.value_ = enhancer_(value, undefined, name_);
     if (notifySpy && isSpyEnabled()) {
-      var _this$value_;
       // only notify spy if this is a stand-alone observable
       spyReport({
         type: CREATE,
         object: this,
         observableKind: "value",
         debugObjectName: this.name_,
-        newValue: "" + ((_this$value_ = this.value_) == null ? void 0 : _this$value_.toString())
+        newValue: this.value_
       });
     }
   }
@@ -1984,34 +1996,41 @@ function endBatch() {
     // the nested call instead of recursing; the outer loop re-reads list.length on
     // every iteration, so it picks up anything the nested dispose() pushes onto the
     // same pendingUnobservations array.
-    if (!globalState.isRunningUnobservations) {
-      globalState.isRunningUnobservations = true;
-      try {
-        const list = globalState.pendingUnobservations;
-        for (let i = 0; i < list.length; i++) {
-          const observable = list[i];
-          observable.isPendingUnobservation = false;
-          if (!observable.observers_ || observable.observers_.size === 0) {
-            if (observable.isBeingObserved) {
-              // if this observable had reactive observers, trigger the hooks
-              observable.isBeingObserved = false;
-              observable.onBUO();
-            }
-            if (observable instanceof ComputedValue) {
-              // computed values are automatically teared down when the last observer leaves
-              // this process happens recursively, this computed might be the last observabe of another, etc..
-              observable.suspend_();
-            }
-          }
+    if (!globalState.isRunningUnobservations && globalState.pendingUnobservations.length > 0) {
+      runPendingUnobservations();
+    }
+  }
+}
+// Only called when there is something to unobserve, so the common endBatch() skips the
+// try/finally and the pendingUnobservations reallocation entirely
+function runPendingUnobservations() {
+  globalState.isRunningUnobservations = true;
+  try {
+    const list = globalState.pendingUnobservations;
+    for (let i = 0; i < list.length; i++) {
+      const observable = list[i];
+      observable.isPendingUnobservation = false;
+      if (!observable.observers_ || observable.observers_.size === 0) {
+        // release the empty Set so unobserved atoms don't keep paying for it
+        observable.observers_ = null;
+        if (observable.isBeingObserved) {
+          // if this observable had reactive observers, trigger the hooks
+          observable.isBeingObserved = false;
+          observable.onBUO();
+        }
+        if (observable instanceof ComputedValue) {
+          // computed values are automatically teared down when the last observer leaves
+          // this process happens recursively, this computed might be the last observabe of another, etc..
+          observable.suspend_();
         }
-        globalState.pendingUnobservations = [];
-      } finally {
-        // Always release the guard, even if an onBUO handler (user code) threw,
-        // otherwise every future endBatch() would see isRunningUnobservations
-        // stuck true and silently stop draining pendingUnobservations forever.
-        globalState.isRunningUnobservations = false;
       }
     }
+    globalState.pendingUnobservations = [];
+  } finally {
+    // Always release the guard, even if an onBUO handler (user code) threw,
+    // otherwise every future endBatch() would see isRunningUnobservations
+    // stuck true and silently stop draining pendingUnobservations forever.
+    globalState.isRunningUnobservations = false;
   }
 }
 /**
@@ -2141,6 +2160,7 @@ class Reaction {
     this.runId_ = 0;
     this.unboundDepsCount_ = 0;
     this.flags_ = 0b00000;
+    this.removeAbortListener_ = undefined;
     this.name_ = name_;
     this.onInvalidate_ = onInvalidate_;
     this.errorHandler_ = errorHandler_;
@@ -2277,7 +2297,10 @@ class Reaction {
   }
   dispose() {
     if (!this.isDisposed) {
+      var _this$removeAbortList;
       this.isDisposed = true;
+      // also covers self-disposal (`r.dispose()`, `when`), which bypasses the disposer
+      (_this$removeAbortList = this.removeAbortListener_) == null || _this$removeAbortList.call(this);
       if (!this.isRunning) {
         // if disposed while running, clean up later. Maybe not optimal, but rare case
         startBatch();
@@ -2287,11 +2310,11 @@ class Reaction {
     }
   }
   getDisposer_(abortSignal) {
-    const dispose = () => {
-      this.dispose();
-      abortSignal == null || abortSignal.removeEventListener == null || abortSignal.removeEventListener("abort", dispose);
-    };
-    abortSignal == null || abortSignal.addEventListener == null || abortSignal.addEventListener("abort", dispose);
+    const dispose = () => this.dispose();
+    if (abortSignal != null && abortSignal.addEventListener && !this.isDisposed) {
+      abortSignal.addEventListener("abort", dispose);
+      this.removeAbortListener_ = () => abortSignal.removeEventListener == null ? void 0 : abortSignal.removeEventListener("abort", dispose);
+    }
     dispose[$mobx] = this;
     if ("dispose" in Symbol && typeof Symbol.dispose === "symbol") {
       dispose[Symbol.dispose] = dispose;
@@ -3290,8 +3313,13 @@ function hasInterceptors(interceptable) {
   return interceptable.interceptors_ !== undefined && interceptable.interceptors_.length > 0;
 }
 function registerInterceptor(interceptable, handler) {
-  const interceptors = interceptable.interceptors_ || (interceptable.interceptors_ = []);
-  interceptors.push(handler);
+  let interceptors = interceptable.interceptors_;
+  if (interceptors) {
+    interceptors.push(handler);
+  } else {
+    // Allocate at the exact size: pushing onto an empty array over-allocates its backing store
+    interceptors = interceptable.interceptors_ = [handler];
+  }
   return once(() => {
     const idx = interceptors.indexOf(handler);
     if (idx !== -1) {
@@ -3323,8 +3351,13 @@ function hasListeners(listenable) {
   return listenable.changeListeners_ !== undefined && listenable.changeListeners_.length > 0;
 }
 function registerListener(listenable, handler) {
-  const listeners = listenable.changeListeners_ || (listenable.changeListeners_ = []);
-  listeners.push(handler);
+  let listeners = listenable.changeListeners_;
+  if (listeners) {
+    listeners.push(handler);
+  } else {
+    // Allocate at the exact size: pushing onto an empty array over-allocates its backing store
+    listeners = listenable.changeListeners_ = [handler];
+  }
   return once(() => {
     const idx = listeners.indexOf(handler);
     if (idx !== -1) {
@@ -3438,8 +3471,7 @@ const arrayTraps = {
     const adm = target[$mobx];
     if (name === "length") {
       adm.setArrayLength_(value);
-    }
-    if (typeof name === "symbol" || isNaN(name)) {
+    } else if (typeof name === "symbol" || isNaN(name)) {
       target[name] = value;
     } else {
       // numeric string
@@ -3484,7 +3516,7 @@ class ObservableArrayAdministration {
     return this.values_.length;
   }
   setArrayLength_(newLength) {
-    if (typeof newLength !== "number" || isNaN(newLength) || newLength < 0) {
+    if (!Number.isInteger(newLength) || newLength < 0) {
       die(40, newLength);
     }
     let currentLength = this.values_.length;
@@ -4266,7 +4298,8 @@ class ObservableSet {
     }
     if (!this.has(value)) {
       transaction(() => {
-        this.data_.add(this.enhancer_(value, undefined));
+        value = this.enhancer_(value, undefined); // report the stored value, like map and array
+        this.data_.add(value);
         this.atom_.reportChanged();
       });
       const notifySpy = isSpyEnabled();