@inboxsdk/core 0.2.28-alpha.5 → 0.2.28

package/src/injected-js/xhr-proxy-factory.js

@@ -1,19 +1,19 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = XHRProxyFactory;
-var _has = _interopRequireDefault(require("lodash/has"));
-var _noop = _interopRequireDefault(require("lodash/noop"));
-var _each = _interopRequireDefault(require("lodash/each"));
-var _filter = _interopRequireDefault(require("lodash/filter"));
-var _includes = _interopRequireDefault(require("lodash/includes"));
-var _once = _interopRequireDefault(require("lodash/once"));
-var _assert = _interopRequireDefault(require("assert"));
-var _events = _interopRequireDefault(require("events"));
-var _querystring = require("querystring");
+/* @flow */
+
+import has from 'lodash/has';
+import noop from 'lodash/noop';
+import each from 'lodash/each';
+import filter from 'lodash/filter';
+import includes from 'lodash/includes';
+import once from 'lodash/once';
+import assert from 'assert';
+import EventEmitter from 'events';
+import { parse as deparam } from 'querystring';
+
+export type Opts = {
+  logError: (error: Error, details: any) => void,
+};
+
 const WARNING_TIMEOUT = 60 * 1000;
 
 /**
@@ -35,6 +35,94 @@ const WARNING_TIMEOUT = 60 * 1000;
  * @property {string} [modifiedResponseText]
  */
 
+export type XHRProxyConnectionDetails = {
+  method: string,
+  url: string,
+  params: { [key: string]: string },
+  headers: { [name: string]: string },
+  responseType: string,
+  originalSendBody: ?string,
+};
+
+export type XHRProxyConnectionDetailsWithResponse =
+  XHRProxyConnectionDetails & {
+    status: number,
+    originalResponseText: string,
+    modifiedResponseText: string,
+  };
+
+export type XHRProxyConnectionDetailsAfterListeners =
+  XHRProxyConnectionDetails & {
+    status: number,
+    originalResponseText: ?string,
+    modifiedResponseText: ?string,
+  };
+
+/**
+ * Thing
+ *
+ * @callback XHRProxyWrapperCallback
+ * @param {XHRProxyConnectionDetails} connection
+ */
+
+type Request = {|
+  method: string,
+  url: string,
+  body: string,
+|};
+
+/**
+ * Wrapper object contains optional callbacks that get run for completed
+ * requests, and a required isRelevantTo method that filters what types of
+ * requests the methods should be called for. All methods are passed an object
+ * with details about the connection as the first argument. Some methods are
+ * called with a relevant second argument (which is also present within the
+ * connection argument).
+ *
+ * @typedef {Object} XHRProxyWrapper
+ * @property {XHRProxyWrapperCallback} isRelevantTo - returns true if wrapper should be used
+ *  for request.
+ * @property {XHRProxyWrapperCallback} [originalSendBodyLogger] - called with value passed to
+ *  send.
+ * @property {XHRProxyWrapperCallback} [requestChanger] - Allows the protocol, URL, and body
+ *  to be changed together before the connection is opened and sent.
+ * @property {XHRProxyWrapperCallback} [originalResponseTextLogger] - called with the responseText as
+ *  given by the server. Is not called if responseType is set to a value besides 'text'.
+ * @property {XHRProxyWrapperCallback} [responseTextChanger] - called with the responseText as given
+ *  by the server and returns new responseText value. Is not called if responseType
+ * is set to a value besides 'text'.
+ * @property {XHRProxyWrapperCallback} [finalResponseTextLogger] - called with the responseText as
+ *  delivered to application code. Is not called if responseType is set to a value besides 'text'.
+ * @property {XHRProxyWrapperCallback} [afterListeners] - called after all event listeners
+ *  for readystatechange have run
+ */
+export type Wrapper = {|
+  isRelevantTo: (connection: XHRProxyConnectionDetails) => boolean,
+  originalSendBodyLogger?: (
+    connection: XHRProxyConnectionDetails,
+    body: string
+  ) => void,
+  requestChanger?: (
+    connection: XHRProxyConnectionDetails,
+    request: Object
+  ) => Request | Promise<Request>,
+  originalResponseTextLogger?: (
+    connection: XHRProxyConnectionDetailsWithResponse,
+    originalResponseText: string
+  ) => void,
+  responseTextChanger?: (
+    connection: XHRProxyConnectionDetailsWithResponse,
+    originalResponseText: string
+  ) => string | Promise<string>,
+  finalResponseTextLogger?: (
+    connection: XHRProxyConnectionDetailsWithResponse,
+    finalResponseText: string
+  ) => void,
+  afterListeners?: (
+    connection: XHRProxyConnectionDetailsAfterListeners
+  ) => void,
+|};
+
 /**
  * Creates a drop-in replacement for the XMLHttpRequest constructor that can
  * have wrappers which may log or modify server responses. See
@@ -45,34 +133,69 @@ const WARNING_TIMEOUT = 60 * 1000;
  * @param {Object} [opts] - Can specify a logError function
  * @returns {function} wrapped XMLHttpRequest-like constructor
  */
-function XHRProxyFactory(XHR, wrappers, opts) {
-  const logError = opts && opts.logError || function (error, label) {
-    setTimeout(function () {
-      // let window.onerror log this
-      throw error;
-    }, 1);
-  };
+export default function XHRProxyFactory(
+  XHR: typeof XMLHttpRequest,
+  wrappers: Wrapper[],
+  opts: Opts
+): typeof XMLHttpRequest {
+  const logError =
+    (opts && opts.logError) ||
+    function (error, label) {
+      setTimeout(function () {
+        // let window.onerror log this
+        throw error;
+      }, 1);
+    };
+
   function transformEvent(oldTarget, newTarget, event) {
     const newEvent = {};
-    Object.keys(event).concat(['bubbles', 'cancelBubble', 'cancelable', 'defaultPrevented', 'preventDefault', 'stopPropagation', 'stopImmediatePropagation', 'lengthComputable', 'loaded', 'total', 'type', 'currentTarget', 'target', 'srcElement', 'NONE', 'CAPTURING_PHASE', 'AT_TARGET', 'BUBBLING_PHASE', 'eventPhase']).filter(name => name in event).forEach(name => {
-      const value = event[name];
-      if (value === oldTarget) {
-        newEvent[name] = newTarget;
-      } else if (typeof value === 'function') {
-        newEvent[name] = value.bind(event);
-      } else {
-        newEvent[name] = value;
-      }
-    });
+    Object.keys(event)
+      .concat([
+        'bubbles',
+        'cancelBubble',
+        'cancelable',
+        'defaultPrevented',
+        'preventDefault',
+        'stopPropagation',
+        'stopImmediatePropagation',
+        'lengthComputable',
+        'loaded',
+        'total',
+        'type',
+        'currentTarget',
+        'target',
+        'srcElement',
+        'NONE',
+        'CAPTURING_PHASE',
+        'AT_TARGET',
+        'BUBBLING_PHASE',
+        'eventPhase',
+      ])
+      .filter((name) => name in event)
+      .forEach((name) => {
+        const value = (event: any)[name];
+        if (value === oldTarget) {
+          newEvent[name] = newTarget;
+        } else if (typeof value === 'function') {
+          newEvent[name] = value.bind(event);
+        } else {
+          newEvent[name] = value;
+        }
+      });
     return newEvent;
   }
+
   function wrapEventListener(oldTarget, newTarget, listener) {
     return function (event) {
-      return listener.call(newTarget, transformEvent(oldTarget, newTarget, event));
+      return listener.call(
+        newTarget,
+        transformEvent(oldTarget, newTarget, event)
+      );
     };
   }
+
   function findApplicableWrappers(wrappers, connection) {
-    return (0, _filter.default)(wrappers, function (wrapper) {
+    return filter(wrappers, function (wrapper) {
       try {
         return wrapper.isRelevantTo(connection);
       } catch (e) {
@@ -80,16 +203,21 @@ function XHRProxyFactory(XHR, wrappers, opts) {
       }
     });
   }
+
   function XHRProxy() {
     this._wrappers = wrappers;
     this._listeners = {};
     this._boundListeners = {};
-    this._events = new _events.default(); // used for internal stuff, not user-visible events
+    this._events = new EventEmitter(); // used for internal stuff, not user-visible events
     this.responseText = '';
     this._openState = false;
+
     if (XHR.bind && XHR.bind.apply) {
       // call constructor with variable number of arguments
-      this._realxhr = new (XHR.bind.apply(XHR, [null].concat(arguments)))();
+      this._realxhr = new ((XHR: any).bind.apply(
+        XHR,
+        [null].concat(arguments)
+      ))();
     } else {
       // Safari's XMLHttpRequest lacks a bind method, but its constructor
       // doesn't support extra arguments anyway, so don't bother logging an
@@ -97,15 +225,20 @@ function XHRProxyFactory(XHR, wrappers, opts) {
       this._realxhr = new XHR();
     }
     const self = this;
+
     const triggerEventListeners = (name, event) => {
       if (this['on' + name]) {
         try {
-          wrapEventListener(this._realxhr, this, this['on' + name]).call(this, event);
+          wrapEventListener(this._realxhr, this, this['on' + name]).call(
+            this,
+            event
+          );
         } catch (e) {
           logError(e, 'XMLHttpRequest event listener error');
         }
       }
-      (0, _each.default)(this._boundListeners[name], boundListener => {
+
+      each(this._boundListeners[name], (boundListener) => {
         try {
           boundListener(event);
         } catch (e) {
@@ -113,51 +246,67 @@ function XHRProxyFactory(XHR, wrappers, opts) {
         }
       });
     };
-    const runRscListeners = event => {
+
+    const runRscListeners = (event) => {
       triggerEventListeners('readystatechange', event);
     };
+
     this._fakeRscEvent = function () {
-      runRscListeners(Object.freeze({
-        bubbles: false,
-        cancelBubble: false,
-        cancelable: false,
-        defaultPrevented: false,
-        preventDefault: _noop.default,
-        stopPropagation: _noop.default,
-        stopImmediatePropagation: _noop.default,
-        type: 'readystatechange',
-        currentTarget: this,
-        target: this,
-        srcElement: this,
-        NONE: 0,
-        CAPTURING_PHASE: 1,
-        AT_TARGET: 2,
-        BUBBLING_PHASE: 3,
-        eventPhase: 0
-      }));
+      runRscListeners(
+        Object.freeze({
+          bubbles: false,
+          cancelBubble: false,
+          cancelable: false,
+          defaultPrevented: false,
+          preventDefault: noop,
+          stopPropagation: noop,
+          stopImmediatePropagation: noop,
+          type: 'readystatechange',
+          currentTarget: this,
+          target: this,
+          srcElement: this,
+          NONE: 0,
+          CAPTURING_PHASE: 1,
+          AT_TARGET: 2,
+          BUBBLING_PHASE: 3,
+          eventPhase: 0,
+        })
+      );
     };
-    const deliverFinalRsc = event => {
+
+    const deliverFinalRsc = (event) => {
       this.readyState = 4;
       // Remember the status now before any event handlers are called, just in
       // case one aborts the request.
       var wasSuccess = this.status == 200;
-      var progressEvent = Object.assign({}, transformEvent(this._realxhr, this, event), {
-        lengthComputable: false,
-        loaded: 0,
-        total: 0
-      });
-      var supportsResponseText = !this._realxhr.responseType || this._realxhr.responseType == 'text';
+      var progressEvent = Object.assign(
+        {},
+        transformEvent(this._realxhr, this, event),
+        {
+          lengthComputable: false,
+          loaded: 0,
+          total: 0,
+        }
+      );
+
+      var supportsResponseText =
+        !this._realxhr.responseType || this._realxhr.responseType == 'text';
+
       if (supportsResponseText) {
-        (0, _each.default)(this._activeWrappers, wrapper => {
+        each(this._activeWrappers, (wrapper) => {
           if (wrapper.finalResponseTextLogger) {
             try {
-              wrapper.finalResponseTextLogger(this._connection, this.responseText);
+              wrapper.finalResponseTextLogger(
+                this._connection,
+                this.responseText
+              );
             } catch (e) {
               logError(e);
             }
           }
         });
       }
+
       runRscListeners(event);
       if (wasSuccess) {
         triggerEventListeners('load', progressEvent);
@@ -165,7 +314,8 @@ function XHRProxyFactory(XHR, wrappers, opts) {
         triggerEventListeners('error', progressEvent);
       }
       triggerEventListeners('loadend', progressEvent);
-      (0, _each.default)(this._activeWrappers, wrapper => {
+
+      each(this._activeWrappers, (wrapper) => {
         if (wrapper.afterListeners) {
           try {
             wrapper.afterListeners(this._connection);
@@ -175,104 +325,156 @@ function XHRProxyFactory(XHR, wrappers, opts) {
         }
       });
     };
-    this._realxhr.addEventListener('readystatechange', event => {
-      if (!this._connection) {
-        return;
-      }
-      if (this._realxhr.readyState >= 2) {
-        this._connection.status = this._realxhr.status;
-      }
-      const supportsResponseText = !this._realxhr.responseType || this._realxhr.responseType == 'text';
-
-      // Process the response text.
-      if (this._realxhr.readyState == 4) {
-        if (supportsResponseText) {
-          Object.defineProperty(this._connection, 'originalResponseText', {
-            enumerable: true,
-            writable: false,
-            configurable: false,
-            value: self._realxhr.responseText
-          });
-          (0, _each.default)(this._activeWrappers, wrapper => {
-            if (wrapper.originalResponseTextLogger) {
-              try {
-                wrapper.originalResponseTextLogger(this._connection, this._connection.originalResponseText);
-              } catch (e) {
-                logError(e);
-              }
-            }
-          });
-          const finish = (0, _once.default)(deliverFinalRsc.bind(null, event));
-          if (this._connection.async) {
-            // If the XHR object is re-used for another connection, then we need
-            // to make sure that our upcoming async calls here do nothing.
-            // Remember the current connection object, and do nothing in our async
-            // calls if it no longer matches.
-            const startConnection = this._connection;
-            (async () => {
-              let modifiedResponseText = startConnection.originalResponseText;
-              startConnection.modifiedResponseText = modifiedResponseText;
-              for (let responseTextChanger of this._responseTextChangers) {
-                const longRunWarningTimer = setTimeout(() => {
-                  // eslint-disable-next-line no-console
-                  console.warn('responseTextChanger is taking too long', responseTextChanger, startConnection);
-                }, WARNING_TIMEOUT);
+
+    this._realxhr.addEventListener(
+      'readystatechange',
+      (event: Object) => {
+        if (!this._connection) {
+          return;
+        }
+        if (this._realxhr.readyState >= 2) {
+          this._connection.status = this._realxhr.status;
+        }
+
+        const supportsResponseText =
+          !this._realxhr.responseType || this._realxhr.responseType == 'text';
+
+        // Process the response text.
+        if (this._realxhr.readyState == 4) {
+          if (supportsResponseText) {
+            Object.defineProperty(this._connection, 'originalResponseText', {
+              enumerable: true,
+              writable: false,
+              configurable: false,
+              value: self._realxhr.responseText,
+            });
+
+            each(this._activeWrappers, (wrapper) => {
+              if (wrapper.originalResponseTextLogger) {
                 try {
-                  modifiedResponseText = await responseTextChanger(startConnection, modifiedResponseText);
-                } finally {
-                  clearTimeout(longRunWarningTimer);
-                }
-                if (typeof modifiedResponseText !== 'string') {
-                  throw new Error('responseTextChanger returned non-string value ' + modifiedResponseText);
+                  wrapper.originalResponseTextLogger(
+                    this._connection,
+                    this._connection.originalResponseText
+                  );
+                } catch (e) {
+                  logError(e);
                 }
-                startConnection.modifiedResponseText = modifiedResponseText;
-                if (startConnection !== this._connection) break;
               }
-              return modifiedResponseText;
-            })().then(modifiedResponseText => {
-              if (startConnection === self._connection) {
-                this.responseText = modifiedResponseText;
-                finish();
-              }
-            }, err => {
-              logError(err);
-              if (startConnection === this._connection) {
-                this.responseText = this._realxhr.responseText;
-                finish();
-              }
-            }).catch(logError);
-            return;
+            });
+
+            const finish = once(deliverFinalRsc.bind(null, event));
+            if (this._connection.async) {
+              // If the XHR object is re-used for another connection, then we need
+              // to make sure that our upcoming async calls here do nothing.
+              // Remember the current connection object, and do nothing in our async
+              // calls if it no longer matches.
+              const startConnection = this._connection;
+
+              (async () => {
+                let modifiedResponseText: string =
+                  startConnection.originalResponseText;
+                startConnection.modifiedResponseText = modifiedResponseText;
+
+                for (let responseTextChanger of this._responseTextChangers) {
+                  const longRunWarningTimer = setTimeout(() => {
+                    // eslint-disable-next-line no-console
+                    console.warn(
+                      'responseTextChanger is taking too long',
+                      responseTextChanger,
+                      startConnection
+                    );
+                  }, WARNING_TIMEOUT);
+                  try {
+                    modifiedResponseText = await responseTextChanger(
+                      startConnection,
+                      modifiedResponseText
+                    );
+                  } finally {
+                    clearTimeout(longRunWarningTimer);
+                  }
+                  if (typeof modifiedResponseText !== 'string') {
+                    throw new Error(
+                      'responseTextChanger returned non-string value ' +
+                        modifiedResponseText
+                    );
+                  }
+                  startConnection.modifiedResponseText = modifiedResponseText;
+
+                  if (startConnection !== this._connection) break;
+                }
+
+                return modifiedResponseText;
+              })()
+                .then(
+                  (modifiedResponseText) => {
+                    if (startConnection === self._connection) {
+                      this.responseText = modifiedResponseText;
+                      finish();
+                    }
+                  },
+                  (err) => {
+                    logError(err);
+                    if (startConnection === this._connection) {
+                      this.responseText = this._realxhr.responseText;
+                      finish();
+                    }
+                  }
+                )
+                .catch(logError);
+              return;
+            } else {
+              self.responseText = self._realxhr.responseText;
+            }
           } else {
-            self.responseText = self._realxhr.responseText;
+            self.responseText = '';
           }
+
+          deliverFinalRsc(event);
         } else {
-          self.responseText = '';
-        }
-        deliverFinalRsc(event);
-      } else {
-        if (self._realxhr.readyState == 1 && self.readyState == 1) {
-          // Delayed open+send just happened. We already delivered an event
-          // for this, so drop this event.
-          return;
-        } else if (self._realxhr.readyState >= 3 && supportsResponseText) {
-          if (self._responseTextChangers.length) {
-            // If we're going to transform the final response, then we don't
-            // want to expose any partial untransformed responses and we don't
-            // want to bother trying to transform partial responses. Only show
-            // an empty string as the loaded response until the connection is
-            // done.
-            self.responseText = '';
+          if (self._realxhr.readyState == 1 && self.readyState == 1) {
+            // Delayed open+send just happened. We already delivered an event
+            // for this, so drop this event.
+            return;
+          } else if (self._realxhr.readyState >= 3 && supportsResponseText) {
+            if (self._responseTextChangers.length) {
+              // If we're going to transform the final response, then we don't
+              // want to expose any partial untransformed responses and we don't
+              // want to bother trying to transform partial responses. Only show
+              // an empty string as the loaded response until the connection is
+              // done.
+              self.responseText = '';
+            } else {
+              self.responseText = self._realxhr.responseText;
+            }
           } else {
-            self.responseText = self._realxhr.responseText;
+            self.responseText = '';
           }
-        } else {
-          self.responseText = '';
+
+          self.readyState = self._realxhr.readyState;
+          runRscListeners(event);
         }
-        self.readyState = self._realxhr.readyState;
-        runRscListeners(event);
-      }
-    }, false);
-    ['dispatchEvent', 'getAllResponseHeaders', 'getResponseHeader', 'overrideMimeType', 'responseType', 'responseXML', 'responseURL', 'status', 'statusText', 'timeout', 'ontimeout', 'onloadstart', 'onprogress', 'onabort', 'upload', 'withCredentials'].forEach(function (prop) {
+      },
+      false
+    );
+
+    [
+      'dispatchEvent',
+      'getAllResponseHeaders',
+      'getResponseHeader',
+      'overrideMimeType',
+      'responseType',
+      'responseXML',
+      'responseURL',
+      'status',
+      'statusText',
+      'timeout',
+      'ontimeout',
+      'onloadstart',
+      'onprogress',
+      'onabort',
+      'upload',
+      'withCredentials',
+    ].forEach(function (prop) {
       Object.defineProperty(self, prop, {
         enumerable: true,
         configurable: false,
@@ -289,23 +491,29 @@ function XHRProxyFactory(XHR, wrappers, opts) {
             v = wrapEventListener(this._realxhr, this, v);
           }
           self._realxhr[prop] = v;
-        }
+        },
       });
     });
-    Object.defineProperty(self, 'response', {
+
+    (Object: any).defineProperty(self, 'response', {
       enumerable: true,
       configurable: false,
       get: function () {
-        if (!this._realxhr.responseType || this._realxhr.responseType == 'text') {
+        if (
+          !this._realxhr.responseType ||
+          this._realxhr.responseType == 'text'
+        ) {
           return this.responseText;
         } else {
           // We're not trying to transform non-text responses currently.
           return this._realxhr.response;
         }
-      }
+      },
     });
+
     self.readyState = self._realxhr.readyState;
   }
+
   XHRProxy.prototype.abort = function () {
     // Important: If the request has already been sent, the XHR will change
     // its readyState to 4 after abort. However, we sometimes asynchronously
@@ -321,16 +529,21 @@ function XHRProxyFactory(XHR, wrappers, opts) {
     }
     this._realxhr.abort();
   };
+
   XHRProxy.prototype.setRequestHeader = function (name, value) {
     var self = this;
     if (this.readyState != 1) {
       // eslint-disable-next-line no-console
-      console.warn('setRequestHeader improperly called at readyState ' + this.readyState);
+      console.warn(
+        'setRequestHeader improperly called at readyState ' + this.readyState
+      );
     }
     if (!this._openState) {
       throw new Error('Can only set headers after open and before send');
     }
+
     this._connection.headers[name] = value;
+
     if (this._connection.async && this._requestChangers.length) {
       this._events.once('realOpen', function () {
         self._realxhr.setRequestHeader(name, value);
@@ -339,22 +552,24 @@ function XHRProxyFactory(XHR, wrappers, opts) {
       this._realxhr.setRequestHeader(name, value);
     }
   };
+
   XHRProxy.prototype.addEventListener = function (name, listener) {
     if (!this._listeners[name]) {
       this._listeners[name] = [];
       this._boundListeners[name] = [];
     }
-    if (!(0, _includes.default)(this._listeners[name], listener)) {
+    if (!includes(this._listeners[name], listener)) {
       var boundListener = wrapEventListener(this._realxhr, this, listener);
       this._listeners[name].push(listener);
       this._boundListeners[name].push(boundListener);
-      if (!(0, _includes.default)(['readystatechange', 'load', 'error', 'loadend'], name)) {
+      if (!includes(['readystatechange', 'load', 'error', 'loadend'], name)) {
         // certain listeners are called manually so that the final
         // call (when readyState==4) can be delayed.
         this._realxhr.addEventListener(name, boundListener, false);
       }
     }
   };
+
   XHRProxy.prototype.removeEventListener = function (name, listener) {
     if (!this._listeners[name]) {
       return;
@@ -369,34 +584,48 @@ function XHRProxyFactory(XHR, wrappers, opts) {
       this._realxhr.removeEventListener(name, boundListener, false);
     }
   };
+
   XHRProxy.prototype.open = function (method, url, async) {
     // Work around MailTrack issue
     if (!(this instanceof XHRProxy)) {
       return XHR.prototype.open.apply(this, arguments);
     }
+
     var self = this;
     this._connection = {
       method: method,
       url: url,
-      params: (0, _querystring.parse)(url.split('?')[1] || ''),
+      params: deparam(url.split('?')[1] || ''),
       headers: {},
-      async: arguments.length < 3 || !!async
+      async: arguments.length < 3 || !!async,
     };
     this._clientStartedSend = false;
     this._realStartedSend = false;
-    this._activeWrappers = findApplicableWrappers(this._wrappers, this._connection);
-    this._responseTextChangers = this._activeWrappers.map(function (wrapper) {
-      return wrapper.responseTextChanger && wrapper.responseTextChanger.bind(wrapper);
-    }).filter(Boolean);
+    this._activeWrappers = findApplicableWrappers(
+      this._wrappers,
+      this._connection
+    );
+    this._responseTextChangers = this._activeWrappers
+      .map(function (wrapper) {
+        return (
+          wrapper.responseTextChanger &&
+          wrapper.responseTextChanger.bind(wrapper)
+        );
+      })
+      .filter(Boolean);
     this.responseText = '';
     this._openState = true;
+
     function finish(method, url) {
       return self._realxhr.open(method, url, self._connection.async);
     }
+
     if (this._connection.async) {
-      this._requestChangers = this._activeWrappers.map(function (wrapper) {
-        return wrapper.requestChanger && wrapper.requestChanger.bind(wrapper);
-      }).filter(Boolean);
+      this._requestChangers = this._activeWrappers
+        .map(function (wrapper) {
+          return wrapper.requestChanger && wrapper.requestChanger.bind(wrapper);
+        })
+        .filter(Boolean);
       if (this._requestChangers.length) {
         if (this.readyState != 1) {
           this.readyState = 1;
@@ -409,6 +638,7 @@ function XHRProxyFactory(XHR, wrappers, opts) {
       finish(method, url);
     }
   };
+
   XHRProxy.prototype.send = function (body) {
     var self = this;
     this._clientStartedSend = true;
@@ -417,10 +647,11 @@ function XHRProxyFactory(XHR, wrappers, opts) {
       enumerable: true,
       writable: false,
       configurable: false,
-      value: body
+      value: body,
     });
     this._connection.responseType = this._realxhr.responseType || 'text';
-    (0, _each.default)(self._activeWrappers, function (wrapper) {
+
+    each(self._activeWrappers, function (wrapper) {
       if (wrapper.originalSendBodyLogger) {
         try {
           wrapper.originalSendBodyLogger(self._connection, body);
@@ -429,61 +660,80 @@ function XHRProxyFactory(XHR, wrappers, opts) {
         }
       }
     });
+
     function finish(body) {
       self._realStartedSend = true;
       self._realxhr.send(body);
     }
+
     if (this._connection.async && this._requestChangers.length) {
       // If the XHR object is re-used for another connection, then we need
       // to make sure that our upcoming async calls here do nothing.
       // Remember the current connection object, and do nothing in our async
       // calls if it no longer matches. Also check for aborts.
       const startConnection = this._connection;
+
       const request = {
         method: this._connection.method,
         url: this._connection.url,
-        body: body
+        body: body,
       };
+
       (async () => {
         let modifiedRequest = request;
         for (let requestChanger of this._requestChangers) {
           const longRunWarningTimer = setTimeout(() => {
             // eslint-disable-next-line no-console
-            console.warn('requestChanger is taking too long', requestChanger, startConnection);
+            console.warn(
+              'requestChanger is taking too long',
+              requestChanger,
+              startConnection
+            );
           }, WARNING_TIMEOUT);
           try {
-            modifiedRequest = await requestChanger(this._connection, Object.freeze(modifiedRequest));
+            modifiedRequest = await requestChanger(
+              this._connection,
+              Object.freeze(modifiedRequest)
+            );
           } finally {
             clearTimeout(longRunWarningTimer);
           }
-          (0, _assert.default)((0, _has.default)(modifiedRequest, 'method'), 'modifiedRequest has method');
-          (0, _assert.default)((0, _has.default)(modifiedRequest, 'url'), 'modifiedRequest has url');
-          (0, _assert.default)((0, _has.default)(modifiedRequest, 'body'), 'modifiedRequest has body');
-          if (startConnection !== this._connection || this._realStartedSend) break;
+
+          assert(has(modifiedRequest, 'method'), 'modifiedRequest has method');
+          assert(has(modifiedRequest, 'url'), 'modifiedRequest has url');
+          assert(has(modifiedRequest, 'body'), 'modifiedRequest has body');
+
+          if (startConnection !== this._connection || this._realStartedSend)
+            break;
         }
+
         return modifiedRequest;
-      })().catch(err => {
-        logError(err);
-        return request;
-      }).then(modifiedRequest => {
-        if (startConnection === this._connection && !this._realStartedSend) {
-          this._realxhr.open(modifiedRequest.method, modifiedRequest.url);
-          this._events.emit('realOpen');
-          finish(modifiedRequest.body);
-        }
-      });
+      })()
+        .catch((err) => {
+          logError(err);
+          return request;
+        })
+        .then((modifiedRequest) => {
+          if (startConnection === this._connection && !this._realStartedSend) {
+            this._realxhr.open(modifiedRequest.method, modifiedRequest.url);
+            this._events.emit('realOpen');
+            finish(modifiedRequest.body);
+          }
+        });
     } else {
       finish(body);
     }
   };
+
   [XHRProxy, XHRProxy.prototype].forEach(function (obj) {
     Object.assign(obj, {
       UNSENT: 0,
       OPENED: 1,
       HEADERS_RECEIVED: 2,
       LOADING: 3,
-      DONE: 4
+      DONE: 4,
     });
   });
-  return XHRProxy;
-}
+
+  return (XHRProxy: any);
+}