@webex/http-core 3.0.0-beta.4 → 3.0.0-beta.400

package/src/lib/xhr.js

@@ -11,243 +11,250 @@
 // we're trying to diverge as little as possible.
 /* eslint-disable */
 
-"use strict";
-var window = require("global/window")
-var isFunction = require("is-function")
-var parseHeaders = require("parse-headers")
-var xtend = require("xtend")
-
-createXHR.XMLHttpRequest = window.XMLHttpRequest || noop
-createXHR.XDomainRequest = "withCredentials" in (new createXHR.XMLHttpRequest()) ? createXHR.XMLHttpRequest : window.XDomainRequest
-
-forEachArray(["get", "put", "post", "patch", "head", "delete"], function(method) {
-    createXHR[method === "delete" ? "del" : method] = function(uri, options, callback) {
-        options = initParams(uri, options, callback)
-        options.method = method.toUpperCase()
-        return _createXHR(options)
-    }
-})
+'use strict';
+var window = require('global/window');
+var isFunction = require('is-function');
+var parseHeaders = require('parse-headers');
+var xtend = require('xtend');
+
+createXHR.XMLHttpRequest = window.XMLHttpRequest || noop;
+createXHR.XDomainRequest =
+  'withCredentials' in new createXHR.XMLHttpRequest()
+    ? createXHR.XMLHttpRequest
+    : window.XDomainRequest;
+
+forEachArray(['get', 'put', 'post', 'patch', 'head', 'delete'], function (method) {
+  createXHR[method === 'delete' ? 'del' : method] = function (uri, options, callback) {
+    options = initParams(uri, options, callback);
+    options.method = method.toUpperCase();
+    return _createXHR(options);
+  };
+});
 
 function forEachArray(array, iterator) {
-    for (var i = 0; i < array.length; i+= 1) {
-        iterator(array[i])
-    }
+  for (var i = 0; i < array.length; i += 1) {
+    iterator(array[i]);
+  }
 }
 
-function isEmpty(obj){
-    for(var i in obj){
-        if(obj.hasOwnProperty(i)) return false
-    }
-    return true
+function isEmpty(obj) {
+  for (var i in obj) {
+    if (obj.hasOwnProperty(i)) return false;
+  }
+  return true;
 }
 
 function initParams(uri, options, callback) {
-    var params = uri
+  var params = uri;
 
-    if (isFunction(options)) {
-        callback = options
-        if (typeof uri === "string") {
-            params = {uri:uri}
-        }
-    } else {
-        params = xtend(options, {uri: uri})
+  if (isFunction(options)) {
+    callback = options;
+    if (typeof uri === 'string') {
+      params = {uri: uri};
     }
+  } else {
+    params = xtend(options, {uri: uri});
+  }
 
-    params.callback = callback
-    return params
+  params.callback = callback;
+  return params;
 }
 
 function createXHR(uri, options, callback) {
-    options = initParams(uri, options, callback)
-    return _createXHR(options)
+  options = initParams(uri, options, callback);
+  return _createXHR(options);
 }
 
 function _createXHR(options) {
-    if(typeof options.callback === "undefined"){
-        throw new Error("callback argument missing")
+  if (typeof options.callback === 'undefined') {
+    throw new Error('callback argument missing');
+  }
+
+  var called = false;
+  var callback = function cbOnce(err, response, body) {
+    if (!called) {
+      called = true;
+      options.callback(err, response, body);
     }
+  };
 
-    var called = false
-    var callback = function cbOnce(err, response, body){
-        if(!called){
-            called = true
-            options.callback(err, response, body)
-        }
+  function readystatechange() {
+    if (xhr.readyState === 4) {
+      setTimeout(loadFunc, 0);
     }
+  }
 
-    function readystatechange() {
-        if (xhr.readyState === 4) {
-            setTimeout(loadFunc, 0)
-        }
-    }
-
-    function getBody() {
-        // Chrome with requestType=blob throws errors arround when even testing access to responseText
-        var body = undefined
-
-        if (xhr.response) {
-            body = xhr.response
-        } else {
-            body = xhr.responseText || getXml(xhr)
-        }
+  function getBody() {
+    // Chrome with requestType=blob throws errors arround when even testing access to responseText
+    var body = undefined;
 
-        if (isJson) {
-            try {
-                body = JSON.parse(body)
-            } catch (e) {}
-        }
-
-        return body
+    if (xhr.response) {
+      body = xhr.response;
+    } else {
+      body = xhr.responseText || getXml(xhr);
     }
 
-    function errorFunc(evt) {
-        clearTimeout(timeoutTimer)
-        if(!(evt instanceof Error)){
-            evt = new Error("" + (evt || "Unknown XMLHttpRequest Error") )
-        }
-        evt.statusCode = 0
-        return callback(evt, failureResponse)
+    if (isJson) {
+      try {
+        body = JSON.parse(body);
+      } catch (e) {}
     }
 
-    // will load the data & process the response in a special response object
-    function loadFunc() {
-        if (aborted) return
-        var status
-        clearTimeout(timeoutTimer)
-        if(options.useXDR && xhr.status===undefined) {
-            //IE8 CORS GET successful response doesn't have a status field, but body is fine
-            status = 200
-        } else {
-            status = (xhr.status === 1223 ? 204 : xhr.status)
-        }
-        var response = failureResponse
-        var err = null
-
-        if (status !== 0){
-            response = {
-                body: getBody(),
-                statusCode: status,
-                method: method,
-                headers: {},
-                url: uri,
-                rawRequest: xhr
-            }
-            if(xhr.getAllResponseHeaders){ //remember xhr can in fact be XDR for CORS in IE
-                response.headers = parseHeaders(xhr.getAllResponseHeaders())
-            }
-        } else {
-            err = new Error("Internal XMLHttpRequest Error")
-        }
-        return callback(err, response, response.body)
+    return body;
+  }
+
+  function errorFunc(evt) {
+    clearTimeout(timeoutTimer);
+    if (!(evt instanceof Error)) {
+      if (evt instanceof ProgressEvent) {
+        evt = new Error(`XMLHttpRequest Error: ProgressEvent: loaded=${evt.loaded}, total=${evt.total}, lengthComputable=${evt.lengthComputable}, target.readyState=${evt.target?.readyState}`)
+      } else {
+        evt = new Error('' + (evt || 'Unknown XMLHttpRequest Error'));
+      }
     }
-
-    var xhr = options.xhr || null
-
-    if (!xhr) {
-        if (options.cors || options.useXDR) {
-            xhr = new createXHR.XDomainRequest()
-        }else{
-            xhr = new createXHR.XMLHttpRequest()
-        }
+    evt.statusCode = 0;
+    return callback(evt, failureResponse);
+  }
+
+  // will load the data & process the response in a special response object
+  function loadFunc() {
+    if (aborted) return;
+    var status;
+    clearTimeout(timeoutTimer);
+    if (options.useXDR && xhr.status === undefined) {
+      //IE8 CORS GET successful response doesn't have a status field, but body is fine
+      status = 200;
+    } else {
+      status = xhr.status === 1223 ? 204 : xhr.status;
     }
+    var response = failureResponse;
+    var err = null;
 
-    var key
-    var aborted
-    var uri = options.uri || options.url
-    var method = options.method || "GET"
-    var body = options.body || options.data
-    var headers = options.headers || {}
-    var sync = !!options.sync
-    var isJson = false
-    var timeoutTimer
-    var failureResponse = {
-        body: undefined,
-        headers: {},
-        statusCode: 0,
+    if (status !== 0) {
+      response = {
+        body: getBody(),
+        statusCode: status,
         method: method,
+        headers: {},
         url: uri,
-        rawRequest: xhr
-    }
-
-    if ("json" in options && options.json !== false) {
-        isJson = true
-        headers["accept"] || headers["Accept"] || (headers["Accept"] = "application/json") //Don't override existing accept header declared by user
-        if (method !== "GET" && method !== "HEAD") {
-            headers["content-type"] || headers["Content-Type"] || (headers["Content-Type"] = "application/json") //Don't override existing accept header declared by user
-            body = JSON.stringify(options.json === true ? body : options.json)
-        }
+        rawRequest: xhr,
+      };
+      if (xhr.getAllResponseHeaders) {
+        //remember xhr can in fact be XDR for CORS in IE
+        response.headers = parseHeaders(xhr.getAllResponseHeaders());
+      }
+    } else {
+      err = new Error('Internal XMLHttpRequest Error');
     }
+    return callback(err, response, response.body);
+  }
 
-    xhr.onreadystatechange = readystatechange
-    xhr.onload = loadFunc
-    xhr.onerror = errorFunc
-    // IE9 must have onprogress be set to a unique function.
-    xhr.onprogress = function () {
-        // IE must die
-    }
-    xhr.onabort = function(){
-        aborted = true;
-    }
-    xhr.ontimeout = errorFunc
-    xhr.open(method, uri, !sync, options.username, options.password)
-    //has to be after open
-    if(!sync) {
-        xhr.withCredentials = !!options.withCredentials
-    }
-    // Cannot set timeout with sync request
-    // not setting timeout on the xhr object, because of old webkits etc. not handling that correctly
-    // both npm's request and jquery 1.x use this kind of timeout, so this is being consistent
-    if (!sync && options.timeout > 0 ) {
-        timeoutTimer = setTimeout(function(){
-            if (aborted) return
-            aborted = true//IE9 may still call readystatechange
-            xhr.abort("timeout")
-            var e = new Error("XMLHttpRequest timeout")
-            e.code = "ETIMEDOUT"
-            errorFunc(e)
-        }, options.timeout )
-    }
+  var xhr = options.xhr || null;
 
-    if (xhr.setRequestHeader) {
-        for(key in headers){
-            if(headers.hasOwnProperty(key)){
-                xhr.setRequestHeader(key, headers[key])
-            }
-        }
-    } else if (options.headers && !isEmpty(options.headers)) {
-        throw new Error("Headers cannot be set on an XDomainRequest object")
+  if (!xhr) {
+    if (options.cors || options.useXDR) {
+      xhr = new createXHR.XDomainRequest();
+    } else {
+      xhr = new createXHR.XMLHttpRequest();
     }
-
-    if ("responseType" in options) {
-        xhr.responseType = options.responseType
+  }
+
+  var key;
+  var aborted;
+  var uri = options.uri || options.url;
+  var method = options.method || 'GET';
+  var body = options.body || options.data;
+  var headers = options.headers || {};
+  var sync = !!options.sync;
+  var isJson = false;
+  var timeoutTimer;
+  var failureResponse = {
+    body: undefined,
+    headers: {},
+    statusCode: 0,
+    method: method,
+    url: uri,
+    rawRequest: xhr,
+  };
+
+  if ('json' in options && options.json !== false) {
+    isJson = true;
+    headers['accept'] || headers['Accept'] || (headers['Accept'] = 'application/json'); //Don't override existing accept header declared by user
+    if (method !== 'GET' && method !== 'HEAD') {
+      headers['content-type'] ||
+        headers['Content-Type'] ||
+        (headers['Content-Type'] = 'application/json'); //Don't override existing accept header declared by user
+      body = JSON.stringify(options.json === true ? body : options.json);
     }
-
-    if ("beforeSend" in options &&
-        typeof options.beforeSend === "function"
-    ) {
-        options.beforeSend(xhr)
+  }
+
+  xhr.onreadystatechange = readystatechange;
+  xhr.onload = loadFunc;
+  xhr.onerror = errorFunc;
+  // IE9 must have onprogress be set to a unique function.
+  xhr.onprogress = function () {
+    // IE must die
+  };
+  xhr.onabort = function () {
+    aborted = true;
+  };
+  xhr.ontimeout = errorFunc;
+  xhr.open(method, uri, !sync, options.username, options.password);
+  //has to be after open
+  if (!sync) {
+    xhr.withCredentials = !!options.withCredentials;
+  }
+  // Cannot set timeout with sync request
+  // not setting timeout on the xhr object, because of old webkits etc. not handling that correctly
+  // both npm's request and jquery 1.x use this kind of timeout, so this is being consistent
+  if (!sync && options.timeout > 0) {
+    timeoutTimer = setTimeout(function () {
+      if (aborted) return;
+      aborted = true; //IE9 may still call readystatechange
+      xhr.abort('timeout');
+      var e = new Error('XMLHttpRequest timeout');
+      e.code = 'ETIMEDOUT';
+      errorFunc(e);
+    }, options.timeout);
+  }
+
+  if (xhr.setRequestHeader) {
+    for (key in headers) {
+      if (headers.hasOwnProperty(key)) {
+        xhr.setRequestHeader(key, headers[key]);
+      }
     }
+  } else if (options.headers && !isEmpty(options.headers)) {
+    throw new Error('Headers cannot be set on an XDomainRequest object');
+  }
 
-    // Microsoft Edge browser sends "undefined" when send is called with undefined value.
-    // XMLHttpRequest spec says to pass null as body to indicate no body
-    // See https://github.com/naugtur/xhr/issues/100.
-    xhr.send(body || null)
+  if ('responseType' in options) {
+    xhr.responseType = options.responseType;
+  }
 
-    return xhr
+  if ('beforeSend' in options && typeof options.beforeSend === 'function') {
+    options.beforeSend(xhr);
+  }
 
+  // Microsoft Edge browser sends "undefined" when send is called with undefined value.
+  // XMLHttpRequest spec says to pass null as body to indicate no body
+  // See https://github.com/naugtur/xhr/issues/100.
+  xhr.send(body || null);
 
+  return xhr;
 }
 
 function getXml(xhr) {
-    if (xhr.responseType === "document") {
-        return xhr.responseXML
-    }
-    var firefoxBugTakenEffect = xhr.responseXML && xhr.responseXML.documentElement.nodeName === "parsererror"
-    if (xhr.responseType === "" && !firefoxBugTakenEffect) {
-        return xhr.responseXML
-    }
-
-    return null
+  if (xhr.responseType === 'document') {
+    return xhr.responseXML;
+  }
+  var firefoxBugTakenEffect =
+    xhr.responseXML && xhr.responseXML.documentElement.nodeName === 'parsererror';
+  if (xhr.responseType === '' && !firefoxBugTakenEffect) {
+    return xhr.responseXML;
+  }
+
+  return null;
 }
 
 function noop() {}

package/src/progress-event.js

@@ -16,17 +16,22 @@ export default function ProgressEvent(loaded, total) {
     loaded: {
       enumerable: true,
       value: loaded,
-      writable: false
+      writable: false,
     },
     total: {
       enumerable: true,
       value: total,
-      writable: false
+      writable: false,
     },
     lengthComputable: {
       enumerable: true,
-      value: isNumber(loaded) && !Number.isNaN(loaded) && isNumber(total) && !Number.isNaN(total) && total > 0,
-      writable: false
-    }
+      value:
+        isNumber(loaded) &&
+        !Number.isNaN(loaded) &&
+        isNumber(total) &&
+        !Number.isNaN(total) &&
+        total > 0,
+      writable: false,
+    },
   });
 }

package/src/request/index.js

@@ -5,6 +5,7 @@
 import {EventEmitter} from 'events';
 
 import _request from './request';
+import {intercept} from './utils';
 
 /**
  * @param {Object} options
@@ -21,42 +22,9 @@ export default function request(options) {
   options.download = new EventEmitter();
   options.upload = new EventEmitter();
 
-  return intercept(options.interceptors, 'Request')
+  return intercept(options, options.interceptors, 'Request')
     .then((...args) => _request(options, ...args))
-    .then((...args) => intercept(options.interceptors.slice().reverse(), 'Response', ...args));
-
-  /**
-   * @param {Array} interceptors
-   * @param {string} key
-   * @param {Object} res
-   * @private
-   * @returns {Promise}
-   */
-  function intercept(interceptors, key, res) {
-    const successKey = `on${key}`;
-    const errorKey = `on${key}Error`;
-
-    return interceptors.reduce(
-      (promise, interceptor) =>
-        promise.then(
-          (result) => {
-            interceptor.logOptions(options);
-            if (interceptor[successKey]) {
-              return interceptor[successKey](options, result);
-            }
-
-            return Promise.resolve(result);
-          },
-          (reason) => {
-            interceptor.logOptions(options);
-            if (interceptor[errorKey]) {
-              return interceptor[errorKey](options, reason);
-            }
-
-            return Promise.reject(reason);
-          }
-        ),
-      Promise.resolve(res)
+    .then((...args) =>
+      intercept(options, options.interceptors.slice().reverse(), 'Response', ...args)
     );
-  }
 }

package/src/request/request.js

@@ -24,12 +24,11 @@ function prepareOptions(options) {
   }
 
   if (isBuffer(options.body)) {
-    return detect(options.body)
-      .then((type) => {
-        options.headers['content-type'] = type;
+    return detect(options.body).then((type) => {
+      options.headers['content-type'] = type;
 
-        return options;
-      });
+      return options;
+    });
   }
 
   return Promise.resolve(options);
@@ -54,24 +53,28 @@ function doRequest(options) {
 
         // I'm not sure why this line is necessary. request seems to be creating
         // buffers that aren't Buffers.
-        if (options.responseType === 'buffer' && response.body.type === 'Buffer' && !isBuffer(response.body)) {
+        if (
+          options.responseType === 'buffer' &&
+          response.body.type === 'Buffer' &&
+          !isBuffer(response.body)
+        ) {
           response.body = Buffer.from(response.body);
         }
 
         if (isBuffer(response.body) && !response.body.type) {
-          resolve(detect(response.body)
-            .then((type) => {
+          resolve(
+            detect(response.body).then((type) => {
               response.body.type = type;
 
               return response;
-            }));
+            })
+          );
 
           return;
         }
 
         resolve(response);
-      }
-      else {
+      } else {
         // Make a network error behave like a browser network error.
         resolve({
           statusCode: 0,
@@ -79,7 +82,7 @@ function doRequest(options) {
           headers: options.headers,
           method: options.method,
           url: options.url,
-          body: error
+          body: error,
         });
       }
     });
@@ -102,6 +105,5 @@ function doRequest(options) {
  * @returns {Promise}
  */
 export default function _request(options) {
-  return prepareOptions(options)
-    .then(doRequest);
+  return prepareOptions(options).then(doRequest);
 }