relay-runtime 1.7.0-rc.1 → 2.0.0

package/lib/RelayObservable.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2013-present, Facebook, Inc.
+ * Copyright (c) Facebook, Inc. and its affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -7,52 +7,9 @@
  * 
  * @format
  */
-
 'use strict';
 
-var _classCallCheck3 = _interopRequireDefault(require('babel-runtime/helpers/classCallCheck'));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
-
-/**
- * A Subscription object is returned from .subscribe(), which can be
- * unsubscribed or checked to see if the resulting subscription has closed.
- */
-
-
-/**
- * An Observer is an object of optional callback functions provided to
- * .subscribe(). Each callback function is invoked when that event occurs.
- */
-
-
-/**
- * A Sink is an object of methods provided by Observable during construction.
- * The methods are to be called to trigger each event. It also contains a closed
- * field to see if the resulting subscription has closed.
- */
-
-
-/**
- * A Source is the required argument when constructing a new Observable. Similar
- * to a Promise constructor, this is a function which is invoked with a Sink,
- * and may return either a cleanup function or a Subscription instance (for use
- * when composing Observables).
- */
-
-
-/**
- * A Subscribable is an interface describing any object which can be subscribed.
- *
- * Note: A sink may be passed directly to .subscribe() as its observer,
- * allowing for easily composing Subscribables.
- */
-
-
-// Note: This should accept Subscribable<T> instead of RelayObservable<T>,
-// however Flow cannot yet distinguish it from T.
 var hostReportError = swallowError;
-
 /**
  * Limited implementation of ESObservable, providing the limited set of behavior
  * Relay networking requires.
@@ -65,26 +22,24 @@ var hostReportError = swallowError;
  * ESObservable: https://github.com/tc39/proposal-observable
  */
 
-var RelayObservable = function () {
+var RelayObservable =
+/*#__PURE__*/
+function () {
   RelayObservable.create = function create(source) {
     return new RelayObservable(source);
-  };
-
-  // Use RelayObservable.create()
+  }; // Use RelayObservable.create()
 
 
   function RelayObservable(source) {
-    (0, _classCallCheck3['default'])(this, RelayObservable);
-
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.NODE_ENV !== "production") {
       // Early runtime errors for ill-formed sources.
       if (!source || typeof source !== 'function') {
         throw new Error('Source must be a Function: ' + String(source));
       }
     }
+
     this._source = source;
   }
-
   /**
    * When an emitted error event is not handled by an Observer, it is reported
    * to the host environment (what the ESObservable spec refers to as
@@ -115,7 +70,6 @@ var RelayObservable = function () {
   RelayObservable.onUnhandledError = function onUnhandledError(callback) {
     hostReportError = callback;
   };
-
   /**
    * Accepts various kinds of data sources, and always returns a RelayObservable
    * useful for accepting the result of a user-provided FetchFunction.
@@ -123,9 +77,8 @@ var RelayObservable = function () {
 
 
   RelayObservable.from = function from(obj) {
-    return isObservable(obj) ? fromObservable(obj) : require('./isPromise')(obj) ? fromPromise(obj) : fromValue(obj);
+    return isObservable(obj) ? fromObservable(obj) : require("./isPromise")(obj) ? fromPromise(obj) : fromValue(obj);
   };
-
   /**
    * Creates a RelayObservable, given a function which expects a legacy
    * Relay Observer as the last argument and which returns a Disposable.
@@ -147,7 +100,6 @@ var RelayObservable = function () {
       };
     });
   };
-
   /**
    * Similar to promise.catch(), observable.catch() handles error events, and
    * provides an alternative observable to use in it's place.
@@ -157,30 +109,23 @@ var RelayObservable = function () {
    */
 
 
-  RelayObservable.prototype['catch'] = function _catch(fn) {
+  var _proto = RelayObservable.prototype;
+
+  _proto["catch"] = function _catch(fn) {
     var _this = this;
 
     return RelayObservable.create(function (sink) {
-      var subscription = void 0;
+      var subscription;
+
       _this.subscribe({
         start: function start(sub) {
           subscription = sub;
         },
         next: sink.next,
         complete: sink.complete,
-        error: function (_error2) {
-          function error(_x) {
-            return _error2.apply(this, arguments);
-          }
-
-          error.toString = function () {
-            return _error2.toString();
-          };
-
-          return error;
-        }(function (error) {
+        error: function error(_error2) {
           try {
-            fn(error).subscribe({
+            fn(_error2).subscribe({
               start: function start(sub) {
                 subscription = sub;
               },
@@ -189,16 +134,18 @@ var RelayObservable = function () {
               error: sink.error
             });
           } catch (error2) {
-            sink.error(error2, true /* isUncaughtThrownError */);
+            sink.error(error2, true
+            /* isUncaughtThrownError */
+            );
           }
-        })
+        }
       });
+
       return function () {
         return subscription.unsubscribe();
       };
     });
   };
-
   /**
    * Returns a new Observable which returns the same values as this one, but
    * modified so that the provided Observer is called to perform a side-effects
@@ -212,7 +159,7 @@ var RelayObservable = function () {
    */
 
 
-  RelayObservable.prototype['do'] = function _do(observer) {
+  _proto["do"] = function _do(observer) {
     var _this2 = this;
 
     return RelayObservable.create(function (sink) {
@@ -221,11 +168,15 @@ var RelayObservable = function () {
           try {
             observer[action] && observer[action].apply(observer, arguments);
           } catch (error) {
-            hostReportError(error, true /* isUncaughtThrownError */);
+            hostReportError(error, true
+            /* isUncaughtThrownError */
+            );
           }
+
           sink[action] && sink[action].apply(sink, arguments);
         };
       };
+
       return _this2.subscribe({
         start: both('start'),
         next: both('next'),
@@ -235,7 +186,6 @@ var RelayObservable = function () {
       });
     });
   };
-
   /**
    * Returns a new Observable which returns the same values as this one, but
    * modified so that the finally callback is performed after completion,
@@ -245,18 +195,18 @@ var RelayObservable = function () {
    */
 
 
-  RelayObservable.prototype['finally'] = function _finally(fn) {
+  _proto["finally"] = function _finally(fn) {
     var _this3 = this;
 
     return RelayObservable.create(function (sink) {
       var subscription = _this3.subscribe(sink);
+
       return function () {
         subscription.unsubscribe();
         fn();
       };
     });
   };
-
   /**
    * Returns a new Observable which is identical to this one, unless this
    * Observable completes before yielding any values, in which case the new
@@ -269,17 +219,17 @@ var RelayObservable = function () {
    */
 
 
-  RelayObservable.prototype.ifEmpty = function ifEmpty(alternate) {
+  _proto.ifEmpty = function ifEmpty(alternate) {
     var _this4 = this;
 
     return RelayObservable.create(function (sink) {
       var hasValue = false;
+
       var current = _this4.subscribe({
         next: function next(value) {
           hasValue = true;
           sink.next(value);
         },
-
         error: sink.error,
         complete: function complete() {
           if (hasValue) {
@@ -289,12 +239,12 @@ var RelayObservable = function () {
           }
         }
       });
+
       return function () {
         current.unsubscribe();
       };
     });
   };
-
   /**
    * Observable's primary API: returns an unsubscribable Subscription to the
    * source of this Observable.
@@ -304,22 +254,22 @@ var RelayObservable = function () {
    */
 
 
-  RelayObservable.prototype.subscribe = function subscribe(observer) {
-    if (process.env.NODE_ENV !== 'production') {
+  _proto.subscribe = function subscribe(observer) {
+    if (process.env.NODE_ENV !== "production") {
       // Early runtime errors for ill-formed observers.
       if (!observer || typeof observer !== 'object') {
         throw new Error('Observer must be an Object with callbacks: ' + String(observer));
       }
     }
+
     return _subscribe(this._source, observer);
   };
-
   /**
    * Supports subscription of a legacy Relay Observer, returning a Disposable.
    */
 
 
-  RelayObservable.prototype.subscribeLegacy = function subscribeLegacy(legacyObserver) {
+  _proto.subscribeLegacy = function subscribeLegacy(legacyObserver) {
     var subscription = this.subscribe({
       next: legacyObserver.onNext,
       error: legacyObserver.onError,
@@ -329,19 +279,36 @@ var RelayObservable = function () {
       dispose: subscription.unsubscribe
     };
   };
-
   /**
    * Returns a new Observerable where each value has been transformed by
    * the mapping function.
    */
 
 
-  RelayObservable.prototype.map = function map(fn) {
-    return this.mergeMap(function (value) {
-      return fromValue(fn(value));
+  _proto.map = function map(fn) {
+    var _this5 = this;
+
+    return RelayObservable.create(function (sink) {
+      var subscription = _this5.subscribe({
+        complete: sink.complete,
+        error: sink.error,
+        next: function next(value) {
+          try {
+            var mapValue = fn(value);
+            sink.next(mapValue);
+          } catch (error) {
+            sink.error(error, true
+            /* isUncaughtThrownError */
+            );
+          }
+        }
+      });
+
+      return function () {
+        subscription.unsubscribe();
+      };
     });
   };
-
   /**
    * Returns a new Observable where each value is replaced with a new Observable
    * by the mapping function, the results of which returned as a single
@@ -349,8 +316,8 @@ var RelayObservable = function () {
    */
 
 
-  RelayObservable.prototype.mergeMap = function mergeMap(fn) {
-    var _this5 = this;
+  _proto.mergeMap = function mergeMap(fn) {
+    var _this6 = this;
 
     return RelayObservable.create(function (sink) {
       var subscriptions = [];
@@ -362,12 +329,13 @@ var RelayObservable = function () {
 
       function complete() {
         subscriptions.splice(subscriptions.indexOf(this._sub), 1);
+
         if (subscriptions.length === 0) {
           sink.complete();
         }
       }
 
-      _this5.subscribe({
+      _this6.subscribe({
         start: start,
         next: function next(value) {
           try {
@@ -380,10 +348,11 @@ var RelayObservable = function () {
               });
             }
           } catch (error) {
-            sink.error(error, true /* isUncaughtThrownError */);
+            sink.error(error, true
+            /* isUncaughtThrownError */
+            );
           }
         },
-
         error: sink.error,
         complete: complete
       });
@@ -396,7 +365,6 @@ var RelayObservable = function () {
       };
     });
   };
-
   /**
    * Returns a new Observable which first mirrors this Observable, then when it
    * completes, waits for `pollInterval` milliseconds before re-subscribing to
@@ -406,19 +374,21 @@ var RelayObservable = function () {
    */
 
 
-  RelayObservable.prototype.poll = function poll(pollInterval) {
-    var _this6 = this;
+  _proto.poll = function poll(pollInterval) {
+    var _this7 = this;
 
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.NODE_ENV !== "production") {
       if (typeof pollInterval !== 'number' || pollInterval <= 0) {
         throw new Error('RelayObservable: Expected pollInterval to be positive, got: ' + pollInterval);
       }
     }
+
     return RelayObservable.create(function (sink) {
-      var subscription = void 0;
-      var timeout = void 0;
+      var subscription;
+      var timeout;
+
       var poll = function poll() {
-        subscription = _this6.subscribe({
+        subscription = _this7.subscribe({
           next: sink.next,
           error: sink.error,
           complete: function complete() {
@@ -426,6 +396,7 @@ var RelayObservable = function () {
           }
         });
       };
+
       poll();
       return function () {
         clearTimeout(timeout);
@@ -433,19 +404,19 @@ var RelayObservable = function () {
       };
     });
   };
-
   /**
    * Returns a Promise which resolves when this Observable yields a first value
    * or when it completes with no value.
    */
 
 
-  RelayObservable.prototype.toPromise = function toPromise() {
-    var _this7 = this;
+  _proto.toPromise = function toPromise() {
+    var _this8 = this;
 
     return new Promise(function (resolve, reject) {
-      var subscription = void 0;
-      _this7.subscribe({
+      var subscription;
+
+      _this8.subscribe({
         start: function start(sub) {
           subscription = sub;
         },
@@ -453,7 +424,6 @@ var RelayObservable = function () {
           resolve(val);
           subscription.unsubscribe();
         },
-
         error: reject,
         complete: resolve
       });
@@ -461,9 +431,7 @@ var RelayObservable = function () {
   };
 
   return RelayObservable;
-}();
-
-// Use declarations to teach Flow how to check isObservable.
+}(); // Use declarations to teach Flow how to check isObservable.
 
 
 function isObservable(obj) {
@@ -495,16 +463,17 @@ function fromValue(value) {
 
 function _subscribe(source, observer) {
   var closed = false;
-  var cleanup = void 0;
-
-  // Ideally we would simply describe a `get closed()` method on the Sink and
+  var cleanup; // Ideally we would simply describe a `get closed()` method on the Sink and
   // Subscription objects below, however not all flow environments we expect
   // Relay to be used within will support property getters, and many minifier
   // tools still do not support ES5 syntax. Instead, we can use defineProperty.
+
   var withClosed = function withClosed(obj) {
-    return Object.defineProperty(obj, 'closed', { get: function get() {
+    return Object.defineProperty(obj, 'closed', {
+      get: function get() {
         return closed;
-      } });
+      }
+    });
   };
 
   function doCleanup() {
@@ -515,109 +484,113 @@ function _subscribe(source, observer) {
         try {
           cleanup();
         } catch (error) {
-          hostReportError(error, true /* isUncaughtThrownError */);
+          hostReportError(error, true
+          /* isUncaughtThrownError */
+          );
         }
       }
+
       cleanup = undefined;
     }
-  }
+  } // Create a Subscription.
+
 
-  // Create a Subscription.
   var subscription = withClosed({
     unsubscribe: function unsubscribe() {
       if (!closed) {
-        closed = true;
+        closed = true; // Tell Observer that unsubscribe was called.
 
-        // Tell Observer that unsubscribe was called.
         try {
           observer.unsubscribe && observer.unsubscribe(subscription);
         } catch (error) {
-          hostReportError(error, true /* isUncaughtThrownError */);
+          hostReportError(error, true
+          /* isUncaughtThrownError */
+          );
         } finally {
           doCleanup();
         }
       }
     }
-  });
+  }); // Tell Observer that observation is about to begin.
 
-  // Tell Observer that observation is about to begin.
   try {
     observer.start && observer.start(subscription);
   } catch (error) {
-    hostReportError(error, true /* isUncaughtThrownError */);
-  }
+    hostReportError(error, true
+    /* isUncaughtThrownError */
+    );
+  } // If closed already, don't bother creating a Sink.
+
 
-  // If closed already, don't bother creating a Sink.
   if (closed) {
     return subscription;
-  }
+  } // Create a Sink respecting subscription state and cleanup.
+
 
-  // Create a Sink respecting subscription state and cleanup.
   var sink = withClosed({
     next: function next(value) {
       if (!closed && observer.next) {
         try {
           observer.next(value);
         } catch (error) {
-          hostReportError(error, true /* isUncaughtThrownError */);
+          hostReportError(error, true
+          /* isUncaughtThrownError */
+          );
         }
       }
     },
-    error: function (_error3) {
-      function error(_x2, _x3) {
-        return _error3.apply(this, arguments);
-      }
-
-      error.toString = function () {
-        return _error3.toString();
-      };
-
-      return error;
-    }(function (error, isUncaughtThrownError) {
+    error: function error(_error3, isUncaughtThrownError) {
       if (closed || !observer.error) {
         closed = true;
-        hostReportError(error, isUncaughtThrownError || false);
+        hostReportError(_error3, isUncaughtThrownError || false);
         doCleanup();
       } else {
         closed = true;
+
         try {
-          observer.error(error);
+          observer.error(_error3);
         } catch (error2) {
-          hostReportError(error2, true /* isUncaughtThrownError */);
+          hostReportError(error2, true
+          /* isUncaughtThrownError */
+          );
         } finally {
           doCleanup();
         }
       }
-    }),
+    },
     complete: function complete() {
       if (!closed) {
         closed = true;
+
         try {
           observer.complete && observer.complete();
         } catch (error) {
-          hostReportError(error, true /* isUncaughtThrownError */);
+          hostReportError(error, true
+          /* isUncaughtThrownError */
+          );
         } finally {
           doCleanup();
         }
       }
     }
-  });
+  }); // If anything goes wrong during observing the source, handle the error.
 
-  // If anything goes wrong during observing the source, handle the error.
   try {
     cleanup = source(sink);
   } catch (error) {
-    sink.error(error, true /* isUncaughtThrownError */);
+    sink.error(error, true
+    /* isUncaughtThrownError */
+    );
   }
 
-  if (process.env.NODE_ENV !== 'production') {
+  if (process.env.NODE_ENV !== "production") {
     // Early runtime errors for ill-formed returned cleanup.
     if (cleanup !== undefined && typeof cleanup !== 'function' && (!cleanup || typeof cleanup.unsubscribe !== 'function')) {
       throw new Error('Returned cleanup function which cannot be called: ' + String(cleanup));
     }
-  }
+  } // If closed before the source function existed, cleanup now.
+
 
-  // If closed before the source function existed, cleanup now.
   if (closed) {
     doCleanup();
   }
@@ -625,11 +598,10 @@ function _subscribe(source, observer) {
   return subscription;
 }
 
-function swallowError(_error, _isUncaughtThrownError) {
-  // do nothing.
+function swallowError(_error, _isUncaughtThrownError) {// do nothing.
 }
 
-if (process.env.NODE_ENV !== 'production') {
+if (process.env.NODE_ENV !== "production") {
   // Default implementation of HostReportErrors() in development builds.
   // Can be replaced by the host application environment.
   RelayObservable.onUnhandledError(function (error, isUncaughtThrownError) {