mobx 7.0.4 → 7.0.6

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # mobx
 
+## 7.0.6
+
+### Patch Changes
+
+-   [`4b1c8d3ea2b3de1a2ae852fd5631e33d28a82b15`](https://github.com/mobxjs/mobx/commit/4b1c8d3ea2b3de1a2ae852fd5631e33d28a82b15) [#4721](https://github.com/mobxjs/mobx/pull/4721) Thanks [@giaBaoJS](https://github.com/giaBaoJS)! - fix: assigning `length` on an observable array now respects `intercept`. A cancelled or modified splice used to be overridden by a direct write to the backing array, which truncated it without notifying observers and made the next mutation throw "Modification exception". A non-integer `length` now throws "Out of range" before touching the array.
+
+-   [`60be47cab0926d12f22449ec6c809fb5ec6601c4`](https://github.com/mobxjs/mobx/commit/60be47cab0926d12f22449ec6c809fb5ec6601c4) [#4716](https://github.com/mobxjs/mobx/pull/4716) Thanks [@AcEKaycgR](https://github.com/AcEKaycgR)! - fix: `observable.box(array)` no longer warns under `observableRequiresReaction` when a spy is active. The `create` spy event now reports `newValue` as the value itself rather than a string, matching the declared `IBoxDidChange` type. Previously the constructor stringified the value, and stringifying an observable array reads its `length`, which counted as an observable read outside a reactive context. Spy listeners that relied on `newValue` being a string for `create` events will now receive the raw value.
+
+-   [`3551aeb051ff922717b03c4fbc04a6b98f7f3b3e`](https://github.com/mobxjs/mobx/commit/3551aeb051ff922717b03c4fbc04a6b98f7f3b3e) [#4717](https://github.com/mobxjs/mobx/pull/4717) Thanks [@breken-ai](https://github.com/breken-ai)! - Remove the `signal` abort listener when a reaction disposes itself (`r.dispose()` or a resolved `when`), so long-lived `AbortSignal`s no longer accumulate listeners that keep disposed reactions in memory
+
+-   [`7e4e27dbfbf0b56770a11e9cba913e5d49c0c6f8`](https://github.com/mobxjs/mobx/commit/7e4e27dbfbf0b56770a11e9cba913e5d49c0c6f8) [#4718](https://github.com/mobxjs/mobx/pull/4718) Thanks [@breken-ai](https://github.com/breken-ai)! - `observe`/`spy` `add` events of an observable Set now report the value that was actually stored (e.g. the observable copy of a plain object), matching ObservableMap and observable arrays, so `set.has(change.newValue)` holds
+
+## 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

package/dist/core/reaction.d.ts

@@ -35,6 +35,7 @@ export declare class Reaction implements IDerivation, IReactionPublic {
     runId_: number;
     unboundDepsCount_: number;
     private flags_;
+    private removeAbortListener_;
     constructor(name_: string | undefined, onInvalidate_: () => void, errorHandler_?: ((error: any, derivation: IDerivation) => void) | undefined, requiresObservable_?: any);
     get isDisposed(): boolean;
     set isDisposed(newValue: boolean);

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_;
@@ -1182,14 +1195,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_
       });
     }
   }
@@ -1988,34 +2000,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;
   }
 }
 /**
@@ -2145,6 +2164,7 @@ class Reaction {
     this.runId_ = 0;
     this.unboundDepsCount_ = 0;
     this.flags_ = 0b00000;
+    this.removeAbortListener_ = undefined;
     this.name_ = name_;
     this.onInvalidate_ = onInvalidate_;
     this.errorHandler_ = errorHandler_;
@@ -2281,7 +2301,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();
@@ -2291,11 +2314,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;
@@ -3294,8 +3317,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) {
@@ -3327,8 +3355,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) {
@@ -3442,8 +3475,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
@@ -3488,7 +3520,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;
@@ -4270,7 +4302,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();