mobx 7.0.4 → 7.0.6

package/dist/mobx.umd.development.js

@@ -822,6 +822,19 @@
         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
@@ -938,7 +951,7 @@
     }
     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_;
@@ -1184,14 +1197,13 @@
         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_
           });
         }
       }
@@ -1990,34 +2002,41 @@
         // 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;
       }
     }
     /**
@@ -2147,6 +2166,7 @@
         this.runId_ = 0;
         this.unboundDepsCount_ = 0;
         this.flags_ = 0b00000;
+        this.removeAbortListener_ = undefined;
         this.name_ = name_;
         this.onInvalidate_ = onInvalidate_;
         this.errorHandler_ = errorHandler_;
@@ -2283,7 +2303,10 @@
       }
       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();
@@ -2293,11 +2316,11 @@
         }
       }
       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;
@@ -3296,8 +3319,13 @@
       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) {
@@ -3329,8 +3357,13 @@
       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) {
@@ -3444,8 +3477,7 @@
         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
@@ -3490,7 +3522,7 @@
         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;
@@ -4272,7 +4304,8 @@
         }
         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();