mobx 7.0.3 → 7.0.5

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # mobx
 
+## 7.0.5
+
+### Patch Changes
+
+-   [`105d66d73529812a8eddc0847891e7f0c574e129`](https://github.com/mobxjs/mobx/commit/105d66d73529812a8eddc0847891e7f0c574e129) [#4713](https://github.com/mobxjs/mobx/pull/4713) Thanks [@xaviergonz](https://github.com/xaviergonz)! - perf: reduce memory used by large, mostly unobserved state. `intercept` / `observe` handler arrays are allocated at their exact size, an observable's internal observers `Set` is released once its last observer leaves, observable objects created with the same `deep` / `autoBind` options share one default annotation instead of allocating their own, and `endBatch()` skips the unobservation pass when nothing is pending.
+
+## 7.0.4
+
+### Patch Changes
+
+-   [`7d85a68fb7e449650535aba22e47ce4d21bfbc10`](https://github.com/mobxjs/mobx/commit/7d85a68fb7e449650535aba22e47ce4d21bfbc10) [#4592](https://github.com/mobxjs/mobx/pull/4592) Thanks [@VimHax](https://github.com/VimHax)! - Extend IReactionDisposer with Disposable
+
+-   [`01211a698b64ea94de8e5f276ff8235fcf8ddf96`](https://github.com/mobxjs/mobx/commit/01211a698b64ea94de8e5f276ff8235fcf8ddf96) [#4700](https://github.com/mobxjs/mobx/pull/4700) Thanks [@kubk](https://github.com/kubk)! - Fix `onBecomeObserved` not firing for dependencies gained when an observed computed is recomputed inside an action.
+
+-   [`6e0a03ef74750b3040c76d3ecc14c4adf202b95a`](https://github.com/mobxjs/mobx/commit/6e0a03ef74750b3040c76d3ecc14c4adf202b95a) [#4710](https://github.com/mobxjs/mobx/pull/4710) Thanks [@kubk](https://github.com/kubk)! - Use TypeScript's built-in `NoInfer` utility instead of a local compatibility alias.
+
 ## 7.0.3
 
 ### Patch Changes

package/dist/api/makeObservable.d.ts

@@ -1,5 +1,3 @@
 import { AnnotationsMap, CreateObservableOptions } from "../internal";
-type NoInfer<T> = [T][T extends any ? 0 : never];
 export declare function makeObservable<T extends object, AdditionalKeys extends PropertyKey = never>(target: T, annotations: AnnotationsMap<T, NoInfer<AdditionalKeys>>, options?: CreateObservableOptions): T;
 export declare function makeAutoObservable<T extends object, AdditionalKeys extends PropertyKey = never>(target: T, overrides?: AnnotationsMap<T, NoInfer<AdditionalKeys>>, options?: CreateObservableOptions): T;
-export {};

package/dist/core/reaction.d.ts

@@ -20,7 +20,7 @@ import { $mobx, IDerivation, IDerivationState_, IObservable, Lambda, GenericAbor
 export interface IReactionPublic {
     dispose(): void;
 }
-export interface IReactionDisposer {
+export interface IReactionDisposer extends Disposable {
     (): void;
     [$mobx]: Reaction;
 }

package/dist/mobx.cjs.development.js

@@ -820,6 +820,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
@@ -936,7 +949,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_;
@@ -1388,7 +1401,10 @@ class ComputedValue {
       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()) {
@@ -1985,34 +2001,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;
   }
 }
 /**
@@ -3291,8 +3314,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) {
@@ -3324,8 +3352,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) {