mobx 7.0.4 → 7.0.5

package/dist/mobx.mjs

@@ -819,6 +819,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
@@ -935,7 +948,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_;
@@ -1996,34 +2009,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;
   }
 }
 /**
@@ -3314,8 +3334,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) {
@@ -3347,8 +3372,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) {