axios 1.0.0-alpha.1 → 1.1.0

package/lib/core/InterceptorManager.js

@@ -1,63 +1,71 @@
 'use strict';
 
-var utils = require('./../utils');
+import utils from './../utils.js';
 
-function InterceptorManager() {
-  this.handlers = [];
-}
-
-/**
- * Add a new interceptor to the stack
- *
- * @param {Function} fulfilled The function to handle `then` for a `Promise`
- * @param {Function} rejected The function to handle `reject` for a `Promise`
- *
- * @return {Number} An ID used to remove interceptor later
- */
-InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
-  this.handlers.push({
-    fulfilled: fulfilled,
-    rejected: rejected,
-    synchronous: options ? options.synchronous : false,
-    runWhen: options ? options.runWhen : null
-  });
-  return this.handlers.length - 1;
-};
+class InterceptorManager {
+  constructor() {
+    this.handlers = [];
+  }
 
-/**
- * Remove an interceptor from the stack
- *
- * @param {Number} id The ID that was returned by `use`
- */
-InterceptorManager.prototype.eject = function eject(id) {
-  if (this.handlers[id]) {
-    this.handlers[id] = null;
+  /**
+   * Add a new interceptor to the stack
+   *
+   * @param {Function} fulfilled The function to handle `then` for a `Promise`
+   * @param {Function} rejected The function to handle `reject` for a `Promise`
+   *
+   * @return {Number} An ID used to remove interceptor later
+   */
+  use(fulfilled, rejected, options) {
+    this.handlers.push({
+      fulfilled,
+      rejected,
+      synchronous: options ? options.synchronous : false,
+      runWhen: options ? options.runWhen : null
+    });
+    return this.handlers.length - 1;
   }
-};
 
-/**
- * Clear all interceptors from the stack
- */
-InterceptorManager.prototype.clear = function clear() {
-  if (this.handlers) {
-    this.handlers = [];
+  /**
+   * Remove an interceptor from the stack
+   *
+   * @param {Number} id The ID that was returned by `use`
+   *
+   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
+   */
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
   }
-};
 
-/**
- * Iterate over all the registered interceptors
- *
- * This method is particularly useful for skipping over any
- * interceptors that may have become `null` calling `eject`.
- *
- * @param {Function} fn The function to call for each interceptor
- */
-InterceptorManager.prototype.forEach = function forEach(fn) {
-  utils.forEach(this.handlers, function forEachHandler(h) {
-    if (h !== null) {
-      fn(h);
+  /**
+   * Clear all interceptors from the stack
+   *
+   * @returns {void}
+   */
+  clear() {
+    if (this.handlers) {
+      this.handlers = [];
     }
-  });
-};
+  }
+
+  /**
+   * Iterate over all the registered interceptors
+   *
+   * This method is particularly useful for skipping over any
+   * interceptors that may have become `null` calling `eject`.
+   *
+   * @param {Function} fn The function to call for each interceptor
+   *
+   * @returns {void}
+   */
+  forEach(fn) {
+    utils.forEach(this.handlers, function forEachHandler(h) {
+      if (h !== null) {
+        fn(h);
+      }
+    });
+  }
+}
 
-module.exports = InterceptorManager;
+export default InterceptorManager;

package/lib/core/buildFullPath.js

@@ -1,7 +1,7 @@
 'use strict';
 
-var isAbsoluteURL = require('../helpers/isAbsoluteURL');
-var combineURLs = require('../helpers/combineURLs');
+import isAbsoluteURL from '../helpers/isAbsoluteURL.js';
+import combineURLs from '../helpers/combineURLs.js';
 
 /**
  * Creates a new URL by combining the baseURL with the requestedURL,
@@ -10,11 +10,12 @@ var combineURLs = require('../helpers/combineURLs');
  *
  * @param {string} baseURL The base URL
  * @param {string} requestedURL Absolute or relative URL to combine
+ *
  * @returns {string} The combined full path
  */
-module.exports = function buildFullPath(baseURL, requestedURL) {
+export default function buildFullPath(baseURL, requestedURL) {
   if (baseURL && !isAbsoluteURL(requestedURL)) {
     return combineURLs(baseURL, requestedURL);
   }
   return requestedURL;
-};
+}

package/lib/core/dispatchRequest.js

@@ -1,14 +1,17 @@
 'use strict';
 
-var utils = require('./../utils');
-var transformData = require('./transformData');
-var isCancel = require('../cancel/isCancel');
-var defaults = require('../defaults');
-var CanceledError = require('../cancel/CanceledError');
-var normalizeHeaderName = require('../helpers/normalizeHeaderName');
+import transformData from './transformData.js';
+import isCancel from '../cancel/isCancel.js';
+import defaults from '../defaults/index.js';
+import CanceledError from '../cancel/CanceledError.js';
+import AxiosHeaders from '../core/AxiosHeaders.js';
 
 /**
  * Throws a `CanceledError` if cancellation has been requested.
+ *
+ * @param {Object} config The config that is to be used for the request
+ *
+ * @returns {void}
  */
 function throwIfCancellationRequested(config) {
   if (config.cancelToken) {
@@ -24,41 +27,21 @@ function throwIfCancellationRequested(config) {
  * Dispatch a request to the server using the configured adapter.
  *
  * @param {object} config The config that is to be used for the request
+ *
  * @returns {Promise} The Promise to be fulfilled
  */
-module.exports = function dispatchRequest(config) {
+export default function dispatchRequest(config) {
   throwIfCancellationRequested(config);
 
-  // Ensure headers exist
-  config.headers = config.headers || {};
+  config.headers = AxiosHeaders.from(config.headers);
 
   // Transform request data
   config.data = transformData.call(
     config,
-    config.data,
-    config.headers,
-    null,
     config.transformRequest
   );
 
-  normalizeHeaderName(config.headers, 'Accept');
-  normalizeHeaderName(config.headers, 'Content-Type');
-
-  // Flatten headers
-  config.headers = utils.merge(
-    config.headers.common || {},
-    config.headers[config.method] || {},
-    config.headers
-  );
-
-  utils.forEach(
-    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
-    function cleanHeaderConfig(method) {
-      delete config.headers[method];
-    }
-  );
-
-  var adapter = config.adapter || defaults.adapter;
+  const adapter = config.adapter || defaults.adapter;
 
   return adapter(config).then(function onAdapterResolution(response) {
     throwIfCancellationRequested(config);
@@ -66,12 +49,12 @@ module.exports = function dispatchRequest(config) {
     // Transform response data
     response.data = transformData.call(
       config,
-      response.data,
-      response.headers,
-      response.status,
-      config.transformResponse
+      config.transformResponse,
+      response
     );
 
+    response.headers = AxiosHeaders.from(response.headers);
+
     return response;
   }, function onAdapterRejection(reason) {
     if (!isCancel(reason)) {
@@ -81,14 +64,13 @@ module.exports = function dispatchRequest(config) {
       if (reason && reason.response) {
         reason.response.data = transformData.call(
           config,
-          reason.response.data,
-          reason.response.headers,
-          reason.response.status,
-          config.transformResponse
+          config.transformResponse,
+          reason.response
         );
+        reason.response.headers = AxiosHeaders.from(reason.response.headers);
       }
     }
 
     return Promise.reject(reason);
   });
-};
+}

package/lib/core/mergeConfig.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var utils = require('../utils');
+import utils from '../utils.js';
 
 /**
  * Config-specific merge-function which creates a new config-object
@@ -8,12 +8,13 @@ var utils = require('../utils');
  *
  * @param {Object} config1
  * @param {Object} config2
+ *
  * @returns {Object} New object resulting from merging config2 to config1
  */
-module.exports = function mergeConfig(config1, config2) {
+export default function mergeConfig(config1, config2) {
   // eslint-disable-next-line no-param-reassign
   config2 = config2 || {};
-  var config = {};
+  const config = {};
 
   function getMergedValue(target, source) {
     if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
@@ -60,7 +61,7 @@ module.exports = function mergeConfig(config1, config2) {
     }
   }
 
-  var mergeMap = {
+  const mergeMap = {
     'url': valueFromConfig2,
     'method': valueFromConfig2,
     'data': valueFromConfig2,
@@ -91,10 +92,10 @@ module.exports = function mergeConfig(config1, config2) {
   };
 
   utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
-    var merge = mergeMap[prop] || mergeDeepProperties;
-    var configValue = merge(prop);
+    const merge = mergeMap[prop] || mergeDeepProperties;
+    const configValue = merge(prop);
     (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
   });
 
   return config;
-};
+}

package/lib/core/settle.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var AxiosError = require('./AxiosError');
+import AxiosError from './AxiosError.js';
 
 /**
  * Resolve or reject a Promise based on response status.
@@ -8,9 +8,11 @@ var AxiosError = require('./AxiosError');
  * @param {Function} resolve A function that resolves the promise.
  * @param {Function} reject A function that rejects the promise.
  * @param {object} response The response.
+ *
+ * @returns {object} The response.
  */
-module.exports = function settle(resolve, reject, response) {
-  var validateStatus = response.config.validateStatus;
+export default function settle(resolve, reject, response) {
+  const validateStatus = response.config.validateStatus;
   if (!response.status || !validateStatus || validateStatus(response.status)) {
     resolve(response);
   } else {
@@ -22,4 +24,4 @@ module.exports = function settle(resolve, reject, response) {
       response
     ));
   }
-};
+}

package/lib/core/transformData.js

@@ -1,23 +1,28 @@
 'use strict';
 
-var utils = require('./../utils');
-var defaults = require('../defaults');
+import utils from './../utils.js';
+import defaults from '../defaults/index.js';
+import AxiosHeaders from '../core/AxiosHeaders.js';
 
 /**
  * Transform the data for a request or a response
  *
- * @param {Object|String} data The data to be transformed
- * @param {Array} headers The headers for the request or response
- * @param {Number} status HTTP status code
  * @param {Array|Function} fns A single function or Array of functions
+ * @param {?Object} response The response object
+ *
  * @returns {*} The resulting transformed data
  */
-module.exports = function transformData(data, headers, status, fns) {
-  var context = this || defaults;
-  /*eslint no-param-reassign:0*/
+export default function transformData(fns, response) {
+  const config = this || defaults;
+  const context = response || config;
+  const headers = AxiosHeaders.from(context.headers);
+  let data = context.data;
+
   utils.forEach(fns, function transform(fn) {
-    data = fn.call(context, data, headers, status);
+    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
   });
 
+  headers.normalize();
+
   return data;
-};
+}

package/lib/defaults/index.js

@@ -1,36 +1,46 @@
 'use strict';
 
-var utils = require('../utils');
-var normalizeHeaderName = require('../helpers/normalizeHeaderName');
-var AxiosError = require('../core/AxiosError');
-var transitionalDefaults = require('./transitional');
-var toFormData = require('../helpers/toFormData');
-var toURLEncodedForm = require('../helpers/toURLEncodedForm');
-var platform = require('../platform');
-var formDataToJSON = require('../helpers/formDataToJSON');
-
-var DEFAULT_CONTENT_TYPE = {
+import utils from '../utils.js';
+import AxiosError from '../core/AxiosError.js';
+import transitionalDefaults from './transitional.js';
+import toFormData from '../helpers/toFormData.js';
+import toURLEncodedForm from '../helpers/toURLEncodedForm.js';
+import platform from '../platform/index.js';
+import formDataToJSON from '../helpers/formDataToJSON.js';
+import adapters from '../adapters/index.js';
+
+const DEFAULT_CONTENT_TYPE = {
   'Content-Type': 'application/x-www-form-urlencoded'
 };
 
-function setContentTypeIfUnset(headers, value) {
-  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
-    headers['Content-Type'] = value;
-  }
-}
-
+/**
+ * If the browser has an XMLHttpRequest object, use the XHR adapter, otherwise use the HTTP
+ * adapter
+ *
+ * @returns {Function}
+ */
 function getDefaultAdapter() {
-  var adapter;
+  let adapter;
   if (typeof XMLHttpRequest !== 'undefined') {
     // For browsers use XHR adapter
-    adapter = require('../adapters/xhr');
-  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
+    adapter = adapters.getAdapter('xhr');
+  } else if (typeof process !== 'undefined' && utils.kindOf(process) === 'process') {
     // For node use HTTP adapter
-    adapter = require('../adapters/http');
+    adapter = adapters.getAdapter('http');
   }
   return adapter;
 }
 
+/**
+ * It takes a string, tries to parse it, and if it fails, it returns the stringified version
+ * of the input
+ *
+ * @param {any} rawValue - The value to be stringified.
+ * @param {Function} parser - A function that parses a string into a JavaScript object.
+ * @param {Function} encoder - A function that takes a value and returns a string.
+ *
+ * @returns {string} A stringified version of the rawValue.
+ */
 function stringifySafely(rawValue, parser, encoder) {
   if (utils.isString(rawValue)) {
     try {
@@ -46,25 +56,22 @@ function stringifySafely(rawValue, parser, encoder) {
   return (encoder || JSON.stringify)(rawValue);
 }
 
-var defaults = {
+const defaults = {
 
   transitional: transitionalDefaults,
 
   adapter: getDefaultAdapter(),
 
   transformRequest: [function transformRequest(data, headers) {
-    normalizeHeaderName(headers, 'Accept');
-    normalizeHeaderName(headers, 'Content-Type');
-
-    var contentType = headers && headers['Content-Type'] || '';
-    var hasJSONContentType = contentType.indexOf('application/json') > -1;
-    var isObjectPayload = utils.isObject(data);
+    const contentType = headers.getContentType() || '';
+    const hasJSONContentType = contentType.indexOf('application/json') > -1;
+    const isObjectPayload = utils.isObject(data);
 
     if (isObjectPayload && utils.isHTMLForm(data)) {
       data = new FormData(data);
     }
 
-    var isFormData = utils.isFormData(data);
+    const isFormData = utils.isFormData(data);
 
     if (isFormData) {
       if (!hasJSONContentType) {
@@ -85,19 +92,19 @@ var defaults = {
       return data.buffer;
     }
     if (utils.isURLSearchParams(data)) {
-      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
+      headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
       return data.toString();
     }
 
-    var isFileList;
+    let isFileList;
 
     if (isObjectPayload) {
-      if (contentType.indexOf('application/x-www-form-urlencoded') !== -1) {
+      if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
         return toURLEncodedForm(data, this.formSerializer).toString();
       }
 
       if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
-        var _FormData = this.env && this.env.FormData;
+        const _FormData = this.env && this.env.FormData;
 
         return toFormData(
           isFileList ? {'files[]': data} : data,
@@ -108,7 +115,7 @@ var defaults = {
     }
 
     if (isObjectPayload || hasJSONContentType ) {
-      setContentTypeIfUnset(headers, 'application/json');
+      headers.setContentType('application/json', false);
       return stringifySafely(data);
     }
 
@@ -116,13 +123,13 @@ var defaults = {
   }],
 
   transformResponse: [function transformResponse(data) {
-    var transitional = this.transitional || defaults.transitional;
-    var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
-    var JSONRequested = this.responseType === 'json';
+    const transitional = this.transitional || defaults.transitional;
+    const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+    const JSONRequested = this.responseType === 'json';
 
     if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {
-      var silentJSONParsing = transitional && transitional.silentJSONParsing;
-      var strictJSONParsing = !silentJSONParsing && JSONRequested;
+      const silentJSONParsing = transitional && transitional.silentJSONParsing;
+      const strictJSONParsing = !silentJSONParsing && JSONRequested;
 
       try {
         return JSON.parse(data);
@@ -175,4 +182,4 @@ utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
   defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
 });
 
-module.exports = defaults;
+export default defaults;

package/lib/defaults/transitional.js

@@ -1,6 +1,6 @@
 'use strict';
 
-module.exports = {
+export default {
   silentJSONParsing: true,
   forcedJSONParsing: true,
   clarifyTimeoutError: false

package/lib/env/classes/FormData.js

@@ -1,2 +1,2 @@
-// eslint-disable-next-line strict
-module.exports = require('form-data');
+import FormData from 'form-data';
+export default FormData;

package/lib/env/data.js

@@ -1,3 +1 @@
-module.exports = {
-  "version": "1.0.0-alpha.1"
-};
+export const VERSION = "1.1.0";