mobx 6.6.2 → 6.7.0

package/dist/mobx.esm.development.js

@@ -2314,7 +2314,7 @@ function reportObserved(observable) {
       }
     }
 
-    return true;
+    return observable.isBeingObserved_;
   } else if (observable.observers_.size === 0 && globalState.inBatch > 0) {
     queueForUnobservation(observable);
   }
@@ -3681,12 +3681,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
     }));
@@ -3695,6 +3708,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;
@@ -4213,17 +4237,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_);
@@ -4251,12 +4281,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);
     }
   };