mobx 7.0.3 → 7.0.5

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_;
@@ -1390,7 +1403,10 @@
           reportObserved(this);
           if (shouldCompute(this)) {
             let prevTrackingContext = globalState.trackingContext;
-            if (this.keepAlive_ && !prevTrackingContext) {
+            if (!prevTrackingContext && (this.keepAlive_ || this.isBeingObserved)) {
+              // An observed or keep-alive computed can be recomputed by an untracked
+              // read, for example from inside an action. Its dependencies are still
+              // transitively observed and must fire their lifecycle hooks
               globalState.trackingContext = this;
             }
             if (this.trackAndCompute()) {
@@ -1987,34 +2003,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;
       }
     }
     /**
@@ -3293,8 +3316,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) {
@@ -3326,8 +3354,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) {