axios 1.0.0-alpha.1 → 1.0.0

package/lib/helpers/isURLSameOrigin.js

@@ -1,68 +1,67 @@
 'use strict';
 
-var utils = require('./../utils');
+import utils from './../utils.js';
+import platform from '../platform/index.js';
 
-module.exports = (
-  utils.isStandardBrowserEnv() ?
+export default platform.isStandardBrowserEnv ?
 
-  // Standard browser envs have full support of the APIs needed to test
-  // whether the request URL is of the same origin as current location.
-    (function standardBrowserEnv() {
-      var msie = /(msie|trident)/i.test(navigator.userAgent);
-      var urlParsingNode = document.createElement('a');
-      var originURL;
+// Standard browser envs have full support of the APIs needed to test
+// whether the request URL is of the same origin as current location.
+  (function standardBrowserEnv() {
+    const msie = /(msie|trident)/i.test(navigator.userAgent);
+    const urlParsingNode = document.createElement('a');
+    let originURL;
 
-      /**
-      * Parse a URL to discover it's components
-      *
-      * @param {String} url The URL to be parsed
-      * @returns {Object}
-      */
-      function resolveURL(url) {
-        var href = url;
-
-        if (msie) {
-          // IE needs attribute set twice to normalize properties
-          urlParsingNode.setAttribute('href', href);
-          href = urlParsingNode.href;
-        }
+    /**
+    * Parse a URL to discover it's components
+    *
+    * @param {String} url The URL to be parsed
+    * @returns {Object}
+    */
+    function resolveURL(url) {
+      let href = url;
 
+      if (msie) {
+        // IE needs attribute set twice to normalize properties
         urlParsingNode.setAttribute('href', href);
-
-        // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
-        return {
-          href: urlParsingNode.href,
-          protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
-          host: urlParsingNode.host,
-          search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
-          hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
-          hostname: urlParsingNode.hostname,
-          port: urlParsingNode.port,
-          pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
-            urlParsingNode.pathname :
-            '/' + urlParsingNode.pathname
-        };
+        href = urlParsingNode.href;
       }
 
-      originURL = resolveURL(window.location.href);
+      urlParsingNode.setAttribute('href', href);
 
-      /**
-      * Determine if a URL shares the same origin as the current location
-      *
-      * @param {String} requestURL The URL to test
-      * @returns {boolean} True if URL shares the same origin, otherwise false
-      */
-      return function isURLSameOrigin(requestURL) {
-        var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
-        return (parsed.protocol === originURL.protocol &&
-            parsed.host === originURL.host);
+      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
+      return {
+        href: urlParsingNode.href,
+        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
+        host: urlParsingNode.host,
+        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
+        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
+        hostname: urlParsingNode.hostname,
+        port: urlParsingNode.port,
+        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
+          urlParsingNode.pathname :
+          '/' + urlParsingNode.pathname
       };
-    })() :
+    }
 
-    // Non standard browser envs (web workers, react-native) lack needed support.
-    (function nonStandardBrowserEnv() {
-      return function isURLSameOrigin() {
-        return true;
-      };
-    })()
-);
+    originURL = resolveURL(window.location.href);
+
+    /**
+    * Determine if a URL shares the same origin as the current location
+    *
+    * @param {String} requestURL The URL to test
+    * @returns {boolean} True if URL shares the same origin, otherwise false
+    */
+    return function isURLSameOrigin(requestURL) {
+      const parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
+      return (parsed.protocol === originURL.protocol &&
+          parsed.host === originURL.host);
+    };
+  })() :
+
+  // Non standard browser envs (web workers, react-native) lack needed support.
+  (function nonStandardBrowserEnv() {
+    return function isURLSameOrigin() {
+      return true;
+    };
+  })();

package/lib/helpers/null.js

@@ -1,2 +1,2 @@
 // eslint-disable-next-line strict
-module.exports = null;
+export default null;

package/lib/helpers/parseHeaders.js

@@ -1,15 +1,15 @@
 'use strict';
 
-var utils = require('./../utils');
+import utils from './../utils.js';
 
-// Headers whose duplicates are ignored by node
+// RawAxiosHeaders whose duplicates are ignored by node
 // c.f. https://nodejs.org/api/http.html#http_message_headers
-var ignoreDuplicateOf = [
+const ignoreDuplicateOf = utils.toObjectSet([
   'age', 'authorization', 'content-length', 'content-type', 'etag',
   'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
   'last-modified', 'location', 'max-forwards', 'proxy-authorization',
   'referer', 'retry-after', 'user-agent'
-];
+]);
 
 /**
  * Parse headers into an object
@@ -21,31 +21,33 @@ var ignoreDuplicateOf = [
  * Transfer-Encoding: chunked
  * ```
  *
- * @param {String} headers Headers needing to be parsed
+ * @param {String} rawHeaders Headers needing to be parsed
+ *
  * @returns {Object} Headers parsed into an object
  */
-module.exports = function parseHeaders(headers) {
-  var parsed = {};
-  var key;
-  var val;
-  var i;
-
-  if (!headers) { return parsed; }
+export default rawHeaders => {
+  const parsed = {};
+  let key;
+  let val;
+  let i;
 
-  utils.forEach(headers.split('\n'), function parser(line) {
+  rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
     i = line.indexOf(':');
-    key = utils.trim(line.slice(0, i)).toLowerCase();
-    val = utils.trim(line.slice(i + 1));
+    key = line.substring(0, i).trim().toLowerCase();
+    val = line.substring(i + 1).trim();
 
-    if (key) {
-      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
-        return;
-      }
-      if (key === 'set-cookie') {
-        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+    if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
+      return;
+    }
+
+    if (key === 'set-cookie') {
+      if (parsed[key]) {
+        parsed[key].push(val);
       } else {
-        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+        parsed[key] = [val];
       }
+    } else {
+      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
     }
   });
 

package/lib/helpers/parseProtocol.js

@@ -1,6 +1,6 @@
 'use strict';
 
-module.exports = function parseProtocol(url) {
-  var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+export default function parseProtocol(url) {
+  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
   return match && match[1] || '';
-};
+}

package/lib/helpers/speedometer.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * Calculate data maxRate
+ * @param {Number} [samplesCount= 10]
+ * @param {Number} [min= 1000]
+ * @returns {Function}
+ */
+function speedometer(samplesCount, min) {
+  samplesCount = samplesCount || 10;
+  const bytes = new Array(samplesCount);
+  const timestamps = new Array(samplesCount);
+  let head = 0;
+  let tail = 0;
+  let firstSampleTS;
+
+  min = min !== undefined ? min : 1000;
+
+  return function push(chunkLength) {
+    const now = Date.now();
+
+    const startedAt = timestamps[tail];
+
+    if (!firstSampleTS) {
+      firstSampleTS = now;
+    }
+
+    bytes[head] = chunkLength;
+    timestamps[head] = now;
+
+    let i = tail;
+    let bytesCount = 0;
+
+    while (i !== head) {
+      bytesCount += bytes[i++];
+      i = i % samplesCount;
+    }
+
+    head = (head + 1) % samplesCount;
+
+    if (head === tail) {
+      tail = (tail + 1) % samplesCount;
+    }
+
+    if (now - firstSampleTS < min) {
+      return;
+    }
+
+    const passed = startedAt && now - startedAt;
+
+    return  passed ? Math.round(bytesCount * 1000 / passed) : undefined;
+  };
+}
+
+export default speedometer;

package/lib/helpers/spread.js

@@ -18,10 +18,11 @@
  *  ```
  *
  * @param {Function} callback
+ *
  * @returns {Function}
  */
-module.exports = function spread(callback) {
+export default function spread(callback) {
   return function wrap(arr) {
     return callback.apply(null, arr);
   };
-};
+}

package/lib/helpers/throttle.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * Throttle decorator
+ * @param {Function} fn
+ * @param {Number} freq
+ * @return {Function}
+ */
+function throttle(fn, freq) {
+  let timestamp = 0;
+  const threshold = 1000 / freq;
+  let timer = null;
+  return function throttled(force, args) {
+    const now = Date.now();
+    if (force || now - timestamp > threshold) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      timestamp = now;
+      return fn.apply(null, args);
+    }
+    if (!timer) {
+      timer = setTimeout(() => {
+        timer = null;
+        timestamp = Date.now();
+        return fn.apply(null, args);
+      }, threshold - (now - timestamp));
+    }
+  };
+}
+
+export default throttle;

package/lib/helpers/toFormData.js

@@ -1,17 +1,40 @@
 'use strict';
 
-var utils = require('../utils');
-var AxiosError = require('../core/AxiosError');
-var envFormData = require('../env/classes/FormData');
+import utils from '../utils.js';
+import AxiosError from '../core/AxiosError.js';
+import envFormData from '../env/classes/FormData.js';
 
+/**
+ * Determines if the given thing is a array or js object.
+ *
+ * @param {string} thing - The object or array to be visited.
+ *
+ * @returns {boolean}
+ */
 function isVisitable(thing) {
   return utils.isPlainObject(thing) || utils.isArray(thing);
 }
 
+/**
+ * It removes the brackets from the end of a string
+ *
+ * @param {string} key - The key of the parameter.
+ *
+ * @returns {string} the key without the brackets.
+ */
 function removeBrackets(key) {
   return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;
 }
 
+/**
+ * It takes a path, a key, and a boolean, and returns a string
+ *
+ * @param {string} path - The path to the current key.
+ * @param {string} key - The key of the current object being iterated over.
+ * @param {string} dots - If true, the key will be rendered with dots instead of brackets.
+ *
+ * @returns {string} The path to the current key.
+ */
 function renderKey(path, key, dots) {
   if (!path) return key;
   return path.concat(key).map(function each(token, i) {
@@ -21,20 +44,35 @@ function renderKey(path, key, dots) {
   }).join(dots ? '.' : '');
 }
 
+/**
+ * If the array is an array and none of its elements are visitable, then it's a flat array.
+ *
+ * @param {Array<any>} arr - The array to check
+ *
+ * @returns {boolean}
+ */
 function isFlatArray(arr) {
   return utils.isArray(arr) && !arr.some(isVisitable);
 }
 
-var predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {
+const predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {
   return /^is[A-Z]/.test(prop);
 });
 
+/**
+ * If the thing is a FormData object, return true, otherwise return false.
+ *
+ * @param {unknown} thing - The thing to check.
+ *
+ * @returns {boolean}
+ */
 function isSpecCompliant(thing) {
   return thing && utils.isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator];
 }
 
 /**
  * Convert a data object to FormData
+ *
  * @param {Object} obj
  * @param {?Object} [formData]
  * @param {?Object} [options]
@@ -42,9 +80,19 @@ function isSpecCompliant(thing) {
  * @param {Boolean} [options.metaTokens = true]
  * @param {Boolean} [options.dots = false]
  * @param {?Boolean} [options.indexes = false]
+ *
  * @returns {Object}
  **/
 
+/**
+ * It converts an object into a FormData object
+ *
+ * @param {Object<any, any>} obj - The object to convert to form data.
+ * @param {string} formData - The FormData object to append to.
+ * @param {Object<string, any>} options
+ *
+ * @returns
+ */
 function toFormData(obj, formData, options) {
   if (!utils.isObject(obj)) {
     throw new TypeError('target must be an object');
@@ -63,13 +111,13 @@ function toFormData(obj, formData, options) {
     return !utils.isUndefined(source[option]);
   });
 
-  var metaTokens = options.metaTokens;
+  const metaTokens = options.metaTokens;
   // eslint-disable-next-line no-use-before-define
-  var visitor = options.visitor || defaultVisitor;
-  var dots = options.dots;
-  var indexes = options.indexes;
-  var _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
-  var useBlob = _Blob && isSpecCompliant(formData);
+  const visitor = options.visitor || defaultVisitor;
+  const dots = options.dots;
+  const indexes = options.indexes;
+  const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
+  const useBlob = _Blob && isSpecCompliant(formData);
 
   if (!utils.isFunction(visitor)) {
     throw new TypeError('visitor must be a function');
@@ -94,15 +142,17 @@ function toFormData(obj, formData, options) {
   }
 
   /**
+   * Default visitor.
    *
    * @param {*} value
    * @param {String|Number} key
    * @param {Array<String|Number>} path
    * @this {FormData}
+   *
    * @returns {boolean} return true to visit the each prop of the value recursively
    */
   function defaultVisitor(value, key, path) {
-    var arr = value;
+    let arr = value;
 
     if (value && !path && typeof value === 'object') {
       if (utils.endsWith(key, '{}')) {
@@ -137,12 +187,12 @@ function toFormData(obj, formData, options) {
     return false;
   }
 
-  var stack = [];
+  const stack = [];
 
-  var exposedHelpers = Object.assign(predicates, {
-    defaultVisitor: defaultVisitor,
-    convertValue: convertValue,
-    isVisitable: isVisitable
+  const exposedHelpers = Object.assign(predicates, {
+    defaultVisitor,
+    convertValue,
+    isVisitable
   });
 
   function build(value, path) {
@@ -155,7 +205,7 @@ function toFormData(obj, formData, options) {
     stack.push(value);
 
     utils.forEach(value, function each(el, key) {
-      var result = !utils.isUndefined(el) && visitor.call(
+      const result = !utils.isUndefined(el) && visitor.call(
         formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers
       );
 
@@ -176,4 +226,4 @@ function toFormData(obj, formData, options) {
   return formData;
 }
 
-module.exports = toFormData;
+export default toFormData;

package/lib/helpers/toURLEncodedForm.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var utils = require('../utils');
-var toFormData = require('./toFormData');
-var platform = require('../platform/');
+import utils from '../utils.js';
+import toFormData from './toFormData.js';
+import platform from '../platform/index.js';
 
-module.exports = function toURLEncodedForm(data, options) {
+export default function toURLEncodedForm(data, options) {
   return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
     visitor: function(value, key, path, helpers) {
       if (platform.isNode && utils.isBuffer(value)) {
@@ -15,4 +15,4 @@ module.exports = function toURLEncodedForm(data, options) {
       return helpers.defaultVisitor.apply(this, arguments);
     }
   }, options));
-};
+}

package/lib/helpers/validator.js

@@ -1,24 +1,26 @@
 'use strict';
 
-var VERSION = require('../env/data').version;
-var AxiosError = require('../core/AxiosError');
+import {VERSION} from '../env/data.js';
+import AxiosError from '../core/AxiosError.js';
 
-var validators = {};
+const validators = {};
 
 // eslint-disable-next-line func-names
-['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) {
+['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {
   validators[type] = function validator(thing) {
     return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
   };
 });
 
-var deprecatedWarnings = {};
+const deprecatedWarnings = {};
 
 /**
  * Transitional option validator
+ *
  * @param {function|boolean?} validator - set to false if the transitional option has been removed
  * @param {string?} version - deprecated version / removed since version
  * @param {string?} message - some message with additional info
+ *
  * @returns {function}
  */
 validators.transitional = function transitional(validator, version, message) {
@@ -27,7 +29,7 @@ validators.transitional = function transitional(validator, version, message) {
   }
 
   // eslint-disable-next-line func-names
-  return function(value, opt, opts) {
+  return (value, opt, opts) => {
     if (validator === false) {
       throw new AxiosError(
         formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),
@@ -52,23 +54,26 @@ validators.transitional = function transitional(validator, version, message) {
 
 /**
  * Assert object's properties type
+ *
  * @param {object} options
  * @param {object} schema
  * @param {boolean?} allowUnknown
+ *
+ * @returns {object}
  */
 
 function assertOptions(options, schema, allowUnknown) {
   if (typeof options !== 'object') {
     throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);
   }
-  var keys = Object.keys(options);
-  var i = keys.length;
+  const keys = Object.keys(options);
+  let i = keys.length;
   while (i-- > 0) {
-    var opt = keys[i];
-    var validator = schema[opt];
+    const opt = keys[i];
+    const validator = schema[opt];
     if (validator) {
-      var value = options[opt];
-      var result = value === undefined || validator(value, opt, options);
+      const value = options[opt];
+      const result = value === undefined || validator(value, opt, options);
       if (result !== true) {
         throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);
       }
@@ -80,7 +85,7 @@ function assertOptions(options, schema, allowUnknown) {
   }
 }
 
-module.exports = {
-  assertOptions: assertOptions,
-  validators: validators
+export default {
+  assertOptions,
+  validators
 };

package/lib/platform/browser/classes/FormData.js

@@ -1,3 +1,3 @@
 'use strict';
 
-module.exports = FormData;
+export default FormData;

package/lib/platform/browser/classes/URLSearchParams.js

@@ -1,5 +1,4 @@
 'use strict';
 
-var AxiosURLSearchParams = require('../../../helpers/AxiosURLSearchParams');
-
-module.exports = typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;
+import AxiosURLSearchParams from '../../../helpers/AxiosURLSearchParams.js';
+export default typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;

package/lib/platform/browser/index.js

@@ -1,11 +1,43 @@
-'use strict';
+import URLSearchParams from './classes/URLSearchParams.js'
+import FormData from './classes/FormData.js'
 
-module.exports = {
+/**
+ * Determine if we're running in a standard browser environment
+ *
+ * This allows axios to run in a web worker, and react-native.
+ * Both environments support XMLHttpRequest, but not fully standard globals.
+ *
+ * web workers:
+ *  typeof window -> undefined
+ *  typeof document -> undefined
+ *
+ * react-native:
+ *  navigator.product -> 'ReactNative'
+ * nativescript
+ *  navigator.product -> 'NativeScript' or 'NS'
+ *
+ * @returns {boolean}
+ */
+const isStandardBrowserEnv = (() => {
+  let product;
+  if (typeof navigator !== 'undefined' && (
+    (product = navigator.product) === 'ReactNative' ||
+    product === 'NativeScript' ||
+    product === 'NS')
+  ) {
+    return false;
+  }
+
+  return typeof window !== 'undefined' && typeof document !== 'undefined';
+})();
+
+export default {
   isBrowser: true,
   classes: {
-    URLSearchParams: require('./classes/URLSearchParams'),
-    FormData: require('./classes/FormData'),
-    Blob: Blob
+    URLSearchParams,
+    FormData,
+    Blob
   },
-  protocols: ['http', 'https', 'file', 'blob', 'url']
+  isStandardBrowserEnv,
+  protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
 };

package/lib/platform/index.js

@@ -1,3 +1,3 @@
-'use strict';
+import platform from './node/index.js';
 
-module.exports = require('./node/');
+export {platform as default}

package/lib/platform/node/classes/FormData.js

@@ -1,3 +1,3 @@
-'use strict';
+import FormData from 'form-data';
 
-module.exports = require('form-data');
+export default FormData;