mobx 6.6.2 → 6.7.0

package/dist/mobx.umd.development.js

@@ -2320,7 +2320,7 @@
           }
         }
 
-        return true;
+        return observable.isBeingObserved_;
       } else if (observable.observers_.size === 0 && globalState.inBatch > 0) {
         queueForUnobservation(observable);
       }
@@ -3687,12 +3687,25 @@
     }
 
     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
         }));
@@ -3701,6 +3714,17 @@
           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;
@@ -4219,17 +4243,23 @@
       };
 
       _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_);
@@ -4257,12 +4287,19 @@
             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);
         }
       };