mobx 6.6.2 → 6.7.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # mobx
 
+## 6.7.0
+
+### Minor Changes
+
+-   [`8cf4784f`](https://github.com/mobxjs/mobx/commit/8cf4784f53857cc977aed641bd778f2c14a080f5) [#3559](https://github.com/mobxjs/mobx/pull/3559) Thanks [@urugator](https://github.com/urugator)! - Proxied observable arrays can now safely read/write out of bound indices. See https://github.com/mobxjs/mobx/discussions/3537
+
+*   [`223e3688`](https://github.com/mobxjs/mobx/commit/223e3688631528a327c79d39e2f497c6e1506165) [#3551](https://github.com/mobxjs/mobx/pull/3551) Thanks [@deadbeef84](https://github.com/deadbeef84)! - Added new option `signal` to `when()`, to support abortion using an AbortSignal / AbortController.
+
+### Patch Changes
+
+-   [`fe25cfed`](https://github.com/mobxjs/mobx/commit/fe25cfede0aee3bddd7fa434a14ed4b40a57ee26) [#3566](https://github.com/mobxjs/mobx/pull/3566) Thanks [@upsuper](https://github.com/upsuper)! - Make return value of reportObserved match invoke of onBecomeObserved
+
 ## 6.6.2
 
 ### Patch Changes

package/dist/api/when.d.ts

@@ -1,8 +1,10 @@
+/// <reference types="node" />
 import { IReactionDisposer, Lambda } from "../internal";
 export interface IWhenOptions {
     name?: string;
     timeout?: number;
     onError?: (error: any) => void;
+    signal?: AbortSignal;
 }
 export declare function when(predicate: () => boolean, opts?: IWhenOptions): Promise<void> & {
     cancel(): void;

package/dist/mobx.cjs.development.js

@@ -2318,7 +2318,7 @@ function reportObserved(observable) {
       }
     }
 
-    return true;
+    return observable.isBeingObserved_;
   } else if (observable.observers_.size === 0 && globalState.inBatch > 0) {
     queueForUnobservation(observable);
   }
@@ -3685,12 +3685,25 @@ function _when(predicate, effect, opts) {
 }
 
 function whenPromise(predicate, opts) {
+  var _opts$signal;
+
   if ( opts && opts.onError) {
     return die("the options 'onError' and 'promise' cannot be combined");
   }
 
+  if (opts != null && (_opts$signal = opts.signal) != null && _opts$signal.aborted) {
+    return Object.assign(Promise.reject(new Error("WHEN_ABORTED")), {
+      cancel: function cancel() {
+        return null;
+      }
+    });
+  }
+
   var cancel;
+  var abort;
   var res = new Promise(function (resolve, reject) {
+    var _opts$signal2;
+
     var disposer = _when(predicate, resolve, _extends({}, opts, {
       onError: reject
     }));
@@ -3699,6 +3712,17 @@ function whenPromise(predicate, opts) {
       disposer();
       reject(new Error("WHEN_CANCELLED"));
     };
+
+    abort = function abort() {
+      disposer();
+      reject(new Error("WHEN_ABORTED"));
+    };
+
+    opts == null ? void 0 : (_opts$signal2 = opts.signal) == null ? void 0 : _opts$signal2.addEventListener("abort", abort);
+  })["finally"](function () {
+    var _opts$signal3;
+
+    return opts == null ? void 0 : (_opts$signal3 = opts.signal) == null ? void 0 : _opts$signal3.removeEventListener("abort", abort);
   });
   res.cancel = cancel;
   return res;
@@ -4217,17 +4241,23 @@ var ObservableArrayAdministration = /*#__PURE__*/function () {
   };
 
   _proto.get_ = function get_(index) {
-    if (index < this.values_.length) {
-      this.atom_.reportObserved();
-      return this.dehanceValue_(this.values_[index]);
+    if (this.legacyMode_ && index >= this.values_.length) {
+      console.warn( "[mobx.array] Attempt to read an array index (" + index + ") that is out of bounds (" + this.values_.length + "). Please check length first. Out of bound indices will not be tracked by MobX" );
+      return undefined;
     }
 
-    console.warn( "[mobx] Out of bounds read: " + index );
+    this.atom_.reportObserved();
+    return this.dehanceValue_(this.values_[index]);
   };
 
   _proto.set_ = function set_(index, newValue) {
     var values = this.values_;
 
+    if (this.legacyMode_ && index > values.length) {
+      // out of bounds
+      die(17, index, values.length);
+    }
+
     if (index < values.length) {
       // update at index in range
       checkIfStateModificationsAreAllowed(this.atom_);
@@ -4255,12 +4285,19 @@ var ObservableArrayAdministration = /*#__PURE__*/function () {
         values[index] = newValue;
         this.notifyArrayChildUpdate_(index, newValue, oldValue);
       }
-    } else if (index === values.length) {
-      // add a new item
-      this.spliceWithArray_(index, 0, [newValue]);
     } else {
-      // out of bounds
-      die(17, index, values.length);
+      // For out of bound index, we don't create an actual sparse array,
+      // but rather fill the holes with undefined (same as setArrayLength_).
+      // This could be considered a bug.
+      var newItems = new Array(index + 1 - values.length);
+
+      for (var i = 0; i < newItems.length - 1; i++) {
+        newItems[i] = undefined;
+      } // No Array.fill everywhere...
+
+
+      newItems[newItems.length - 1] = newValue;
+      this.spliceWithArray_(values.length, 0, newItems);
     }
   };