Comparing axios@0.30.3...axios@1.0.0 • npm-diff.app 📦🔃

+Copyright (c) 2014-present Matt Zabriskie
+# Copyright (c) 2014-present Matt Zabriskie & Collaborators
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 'use strict';
+var utils = require('./utils');
+var bind = require('./helpers/bind');
+var Axios = require('./core/Axios');
+var mergeConfig = require('./core/mergeConfig');
+var defaults = require('./defaults');
+var formDataToJSON = require('./helpers/formDataToJSON');
+import utils from './utils.js';
+import bind from './helpers/bind.js';
+import Axios from './core/Axios.js';
+import mergeConfig from './core/mergeConfig.js';
+import defaults from './defaults/index.js';
+import formDataToJSON from './helpers/formDataToJSON.js';
+import CanceledError from './cancel/CanceledError.js';
+import CancelToken from'./cancel/CancelToken.js';
+import isCancel from'./cancel/isCancel.js';
+import {VERSION} from './env/data.js';
+import toFormData from './helpers/toFormData.js';
+import AxiosError from './core/AxiosError.js';
+import spread from './helpers/spread.js';
+import isAxiosError from './helpers/isAxiosError.js';
 /**
  * Create an instance of Axios
+ *
  * @param {Object} defaultConfig The default config for the instance
+ * @return {Axios} A new instance of Axios
+ *
+ * @returns {Axios} A new instance of Axios
  */
 function createInstance(defaultConfig) {
+  var context = new Axios(defaultConfig);
+  var instance = bind(Axios.prototype.request, context);
+  const context = new Axios(defaultConfig);
+  const instance = bind(Axios.prototype.request, context);
   // Copy axios.prototype to instance
+  utils.extend(instance, Axios.prototype, context);
+  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});
   // Copy context to instance
+  utils.extend(instance, context);
+  utils.extend(instance, context, null, {allOwnKeys: true});
   // Factory for creating new instances
   instance.create = function create(instanceConfig) {
+}
 // Create the default instance to be exported
+var axios = createInstance(defaults);
+const axios = createInstance(defaults);
 // Expose Axios class to allow class inheritance
 axios.Axios = Axios;
 // Expose Cancel & CancelToken
+axios.CanceledError = require('./cancel/CanceledError');
+axios.CancelToken = require('./cancel/CancelToken');
+axios.isCancel = require('./cancel/isCancel');
+axios.VERSION = require('./env/data').version;
+axios.toFormData = require('./helpers/toFormData');
+axios.CanceledError = CanceledError;
+axios.CancelToken = CancelToken;
+axios.isCancel = isCancel;
+axios.VERSION = VERSION;
+axios.toFormData = toFormData;
 // Expose AxiosError class
+axios.AxiosError = require('../lib/core/AxiosError');
+axios.AxiosError = AxiosError;
 // alias for CanceledError for backward compatibility
 axios.Cancel = axios.CanceledError;
 axios.all = function all(promises) {
   return Promise.all(promises);
 };
+axios.spread = require('./helpers/spread');
+axios.spread = spread;
 // Expose isAxiosError
+axios.isAxiosError = require('./helpers/isAxiosError');
+axios.isAxiosError = isAxiosError;
+axios.formToJSON = function(thing) {
+axios.formToJSON = thing => {
   return formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
 };
+module.exports = axios;
+// Allow use of default import syntax in TypeScript
+module.exports.default = axios;
+export default axios;

 'use strict';
+var utils = require('../utils');
+import utils from '../utils.js';
 /**
  * Create an Error with the specified message, config, error code, request and response.
  * @param {Object} [config] The config.
  * @param {Object} [request] The request.
  * @param {Object} [response] The response.
+ *
  * @returns {Error} The created error.
  */
 function AxiosError(message, code, config, request, response) {
+  }
 });
+var prototype = AxiosError.prototype;
+var descriptors = {};
+const prototype = AxiosError.prototype;
+const descriptors = {};
+[
   'ERR_BAD_OPTION_VALUE',
   'ERR_NOT_SUPPORT',
   'ERR_INVALID_URL'
 // eslint-disable-next-line func-names
+].forEach(function(code) {
+].forEach(code => {
   descriptors[code] = {value: code};
 });
 Object.defineProperty(prototype, 'isAxiosError', {value: true});
 // eslint-disable-next-line func-names
+AxiosError.from = function(error, code, config, request, response, customProps) {
+  var axiosError = Object.create(prototype);
+AxiosError.from = (error, code, config, request, response, customProps) => {
+  const axiosError = Object.create(prototype);
   utils.toFlatObject(error, axiosError, function filter(obj) {
     return obj !== Error.prototype;
+  }, prop => {
+    return prop !== 'isAxiosError';
   });
   AxiosError.call(axiosError, error.message, code, config, request, response);
   return axiosError;
 };
+module.exports = AxiosError;
+export default AxiosError;

 'use strict';
+var toFormData = require('./toFormData');
+import toFormData from './toFormData.js';
+/**
+ * It encodes a string by replacing all characters that are not in the unreserved set with
+ * their percent-encoded equivalents
+ *
+ * @param {string} str - The string to encode.
+ *
+ * @returns {string} The encoded string.
+ */
 function encode(str) {
+  var charMap = {
+  const charMap = {
     '!': '%21',
     "'": '%27',
     '(': '%28',
     '%20': '+',
     '%00': '\x00'
   };
+  return encodeURIComponent(str).replace(/[!'\(\)~]|%20|%00/g, function replacer(match) {
+  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
     return charMap[match];
   });
+}
+/**
+ * It takes a params object and converts it to a FormData object
+ *
+ * @param {Object<string, any>} params - The parameters to be converted to a FormData object.
+ * @param {Object<string, any>} options - The options object passed to the Axios constructor.
+ *
+ * @returns {void}
+ */
 function AxiosURLSearchParams(params, options) {
   this._pairs = [];
   params && toFormData(params, this, options);
+}
+var prototype = AxiosURLSearchParams.prototype;
+const prototype = AxiosURLSearchParams.prototype;
 prototype.append = function append(name, value) {
   this._pairs.push([name, value]);
 };
 prototype.toString = function toString(encoder) {
+  var _encode = encoder ? function(value) {
+  const _encode = encoder ? function(value) {
     return encoder.call(this, value, encode);
   } : encode;
   }, '').join('&');
 };
+module.exports = AxiosURLSearchParams;
+export default AxiosURLSearchParams;

 'use strict';
+module.exports = function bind(fn, thisArg) {
+export default function bind(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
   };
+};
+}

 '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,
+ *
  * @param {string} baseURL The base URL
  * @param {string} requestedURL Absolute or relative URL to combine
+ * @param {boolean} allowAbsoluteUrls Set to true to allow absolute URLs
+ *
  * @returns {string} The combined full path
  */
+module.exports = function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
+  var isRelativeURL = !isAbsoluteURL(requestedURL);
+  if (baseURL && (isRelativeURL || allowAbsoluteUrls === false)) {
+export default function buildFullPath(baseURL, requestedURL) {
+  if (baseURL && !isAbsoluteURL(requestedURL)) {
     return combineURLs(baseURL, requestedURL);
+  }
   return requestedURL;
+};
+}

 'use strict';
+var utils = require('../utils');
+var AxiosURLSearchParams = require('../helpers/AxiosURLSearchParams');
+import utils from '../utils.js';
+import AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';
+/**
+ * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
+ * URI encoded counterparts
+ *
+ * @param {string} val The value to be encoded.
+ *
+ * @returns {string} The encoded value.
+ */
 function encode(val) {
   return encodeURIComponent(val).
     replace(/%3A/gi, ':').
  * @param {string} url The base of the url (e.g., http://www.google.com)
  * @param {object} [params] The params to be appended
  * @param {?object} options
+ *
  * @returns {string} The formatted url
  */
+module.exports = function buildURL(url, params, options) {
+export default function buildURL(url, params, options) {
   /*eslint no-param-reassign:0*/
   if (!params) {
     return url;
+  }
+  var hashmarkIndex = url.indexOf('#');
+  const hashmarkIndex = url.indexOf('#');
   if (hashmarkIndex !== -1) {
     url = url.slice(0, hashmarkIndex);
+  }
+  var _encode = options && options.encode || encode;
+  const _encode = options && options.encode || encode;
+  var serializeFn = options && options.serialize;
+  const serializerParams = utils.isURLSearchParams(params) ?
+    params.toString() :
+    new AxiosURLSearchParams(params, options).toString(_encode);
+  var serializedParams;
+  if (serializeFn) {
+    serializedParams = serializeFn(params, options);
+  } else {
+    serializedParams = utils.isURLSearchParams(params) ?
+      params.toString() :
+      new AxiosURLSearchParams(params, options).toString(_encode);
+  if (serializerParams) {
+    url += (url.indexOf('?') === -1 ? '?' : '&') + serializerParams;
+  }
+  if (serializedParams) {
+    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
+  }
   return url;
+};
+}

 'use strict';
+var AxiosError = require('../core/AxiosError');
+var utils = require('../utils');
+import AxiosError from '../core/AxiosError.js';
+import utils from '../utils.js';
 /**
  * A `CanceledError` is an object that is thrown when an operation is canceled.
+ *
+ * @class
  * @param {string=} message The message.
  * @param {Object=} config The config.
  * @param {Object=} request The request.
+ *
+ * @returns {CanceledError} The created error.
  */
 function CanceledError(message, config, request) {
   // eslint-disable-next-line no-eq-null,eqeqeq
   __CANCEL__: true
 });
+module.exports = CanceledError;
+export default CanceledError;

+ *
  * @param {string} baseURL The base URL
  * @param {string} relativeURL The relative URL
+ *
  * @returns {string} The combined URL
  */
+module.exports = function combineURLs(baseURL, relativeURL) {
+export default function combineURLs(baseURL, relativeURL) {
   return relativeURL
+    ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+    ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
     : baseURL;
+};
+}

 '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 support document.cookie
+    (function standardBrowserEnv() {
+      return {
+        write: function write(name, value, expires, path, domain, secure) {
+          var cookie = [];
+          cookie.push(name + '=' + encodeURIComponent(value));
+// Standard browser envs support document.cookie
+  (function standardBrowserEnv() {
+    return {
+      write: function write(name, value, expires, path, domain, secure) {
+        const cookie = [];
+        cookie.push(name + '=' + encodeURIComponent(value));
+          if (utils.isNumber(expires)) {
+            cookie.push('expires=' + new Date(expires).toGMTString());
+          }
+        if (utils.isNumber(expires)) {
+          cookie.push('expires=' + new Date(expires).toGMTString());
+        }
+          if (utils.isString(path)) {
+            cookie.push('path=' + path);
+          }
+        if (utils.isString(path)) {
+          cookie.push('path=' + path);
+        }
+          if (utils.isString(domain)) {
+            cookie.push('domain=' + domain);
+          }
+        if (utils.isString(domain)) {
+          cookie.push('domain=' + domain);
+        }
+          if (secure === true) {
+            cookie.push('secure');
+          }
+        if (secure === true) {
+          cookie.push('secure');
+        }
+          document.cookie = cookie.join('; ');
+        },
+        document.cookie = cookie.join('; ');
+      },
+        read: function read(name) {
+          var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+          return (match ? decodeURIComponent(match[3]) : null);
+        },
+      read: function read(name) {
+        const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+        return (match ? decodeURIComponent(match[3]) : null);
+      },
+        remove: function remove(name) {
+          this.write(name, '', Date.now() - 86400000);
+        }
+      };
+    })() :
+      remove: function remove(name) {
+        this.write(name, '', Date.now() - 86400000);
+      }
+    };
+  })() :
+  // Non standard browser env (web workers, react-native) lack needed support.
+    (function nonStandardBrowserEnv() {
+      return {
+        write: function write() {},
+        read: function read() { return null; },
+        remove: function remove() {}
+      };
+    })()
+);
+// Non standard browser env (web workers, react-native) lack needed support.
+  (function nonStandardBrowserEnv() {
+    return {
+      write: function write() {},
+      read: function read() { return null; },
+      remove: function remove() {}
+    };
+  })();

+module.exports = {
+  version: "0.30.3",
+};
+export const VERSION = "1.0.0";

  * @param {string} method The name of the deprecated method
  * @param {string} [instead] The alternate method to use if applicable
  * @param {string} [docs] The documentation URL to get further details
+ *
+ * @returns {void}
  */
+module.exports = function deprecatedMethod(method, instead, docs) {
+export default function deprecatedMethod(method, instead, docs) {
   try {
     console.warn(
       'DEPRECATED method `' + method + '`.' +
       console.warn('For more information about usage see ' + docs);
+    }
   } catch (e) { /* Ignore */ }
+};
+}

 '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) {
  * 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');
+  const adapter = config.adapter || defaults.adapter;
+  // 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;
   return adapter(config).then(function onAdapterResolution(response) {
     throwIfCancellationRequested(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)) {
       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);
   });
+};
+}

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

 'use strict';
+var utils = require('../utils');
+import utils from '../utils.js';
+/**
+ * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
+ *
+ * @param {string} name - The name of the property to get.
+ *
+ * @returns An array of strings.
+ */
 function parsePropPath(name) {
   // foo[x][y][z]
   // foo.x.y.z
   // foo-x-y-z
   // foo x y z
+  return utils.matchAll(/\w+|\[(\w*)]/g, name).map(function(match) {
+  return utils.matchAll(/\w+|\[(\w*)]/g, name).map(match => {
     return match[0] === '[]' ? '' : match[1] || match[0];
   });
+}
+/**
+ * Convert an array to an object.
+ *
+ * @param {Array<any>} arr - The array to convert to an object.
+ *
+ * @returns An object with the same keys and values as the array.
+ */
 function arrayToObject(arr) {
+  var obj = {};
+  var keys = Object.keys(arr);
+  var i;
+  var len = keys.length;
+  var key;
+  const obj = {};
+  const keys = Object.keys(arr);
+  let i;
+  const len = keys.length;
+  let key;
   for (i = 0; i < len; i++) {
     key = keys[i];
     obj[key] = arr[key];
   return obj;
+}
+/**
+ * It takes a FormData object and returns a JavaScript object
+ *
+ * @param {string} formData The FormData object to convert to JSON.
+ *
+ * @returns {Object<string, any> | null} The converted object.
+ */
 function formDataToJSON(formData) {
   function buildPath(path, value, target, index) {
+    var name = path[index++];
+    if (name === '__proto__') return true;
+    var isNumericKey = Number.isFinite(+name);
+    var isLast = index >= path.length;
+    let name = path[index++];
+    const isNumericKey = Number.isFinite(+name);
+    const isLast = index >= path.length;
     name = !name && utils.isArray(target) ? target.length : name;
     if (isLast) {
+      if (utils.hasOwnProperty(target, name)) {
+      if (utils.hasOwnProp(target, name)) {
         target[name] = [target[name], value];
       } else {
         target[name] = value;
       target[name] = [];
+    }
+    var result = buildPath(path, value, target[name], index);
+    const result = buildPath(path, value, target[name], index);
     if (result && utils.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
+  }
   if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
+    var obj = {};
+    const obj = {};
+    utils.forEachEntry(formData, function(name, value) {
+    utils.forEachEntry(formData, (name, value) => {
       buildPath(parsePropPath(name), value, obj, 0);
     });
   return null;
+}
+module.exports = formDataToJSON;
+export default formDataToJSON;

 'use strict';
+var AxiosError = require('../core/AxiosError');
+var parseProtocol = require('./parseProtocol');
+var platform = require('../platform');
+import AxiosError from '../core/AxiosError.js';
+import parseProtocol from './parseProtocol.js';
+import platform from '../platform/index.js';
+var DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
+const DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
 /**
  * Parse data uri to a Buffer or Blob
+ *
  * @param {String} uri
  * @param {?Boolean} asBlob
  * @param {?Object} options
  * @param {?Function} options.Blob
+ *
  * @returns {Buffer|Blob}
  */
+module.exports = function fromDataURI(uri, asBlob, options) {
+  var _Blob = options && options.Blob || platform.classes.Blob;
+  var protocol = parseProtocol(uri);
+export default function fromDataURI(uri, asBlob, options) {
+  const _Blob = options && options.Blob || platform.classes.Blob;
+  const protocol = parseProtocol(uri);
   if (asBlob === undefined && _Blob) {
     asBlob = true;
   if (protocol === 'data') {
     uri = protocol.length ? uri.slice(protocol.length + 1) : uri;
+    var match = DATA_URL_PATTERN.exec(uri);
+    const match = DATA_URL_PATTERN.exec(uri);
     if (!match) {
       throw new AxiosError('Invalid URL', AxiosError.ERR_INVALID_URL);
+    }
+    var mime = match[1];
+    var isBase64 = match[2];
+    var body = match[3];
+    var buffer = Buffer.from(decodeURIComponent(body), isBase64 ? 'base64' : 'utf8');
+    const mime = match[1];
+    const isBase64 = match[2];
+    const body = match[3];
+    const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? 'base64' : 'utf8');
     if (asBlob) {
       if (!_Blob) {
+  }
   throw new AxiosError('Unsupported protocol ' + protocol, AxiosError.ERR_NOT_SUPPORT);
+};
+}

+module.exports = require('./lib/axios');
+import axios from './lib/axios.js';
+export default axios;

+'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
   },
+  isStandardBrowserEnv,
   protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
 };

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

 'use strict';
+var utils = require('./../utils');
+import utils from './../utils.js';
+function InterceptorManager() {
+  this.handlers = [];
+}
+class InterceptorManager {
+  constructor() {
+    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;
+};
+/**
+ * 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 = [];
+    }
+  });
+};
+  }
+module.exports = InterceptorManager;
+  /**
+   * 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);
+      }
+    });
+  }
+}
+export default InterceptorManager;

  * Determines whether the specified URL is absolute
+ *
  * @param {string} url The URL to test
+ *
  * @returns {boolean} True if the specified URL is absolute, otherwise false
  */
+module.exports = function isAbsoluteURL(url) {
+export default function isAbsoluteURL(url) {
   // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
   // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
   // by any combination of letters, digits, plus, period, or hyphen.
   return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+};
+}

 'use strict';
+var utils = require('./../utils');
+import utils from './../utils.js';
 /**
  * Determines whether the payload is an error thrown by Axios
+ *
  * @param {*} payload The value to test
+ *
  * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
  */
+module.exports = function isAxiosError(payload) {
+export default function isAxiosError(payload) {
   return utils.isObject(payload) && (payload.isAxiosError === true);
+};
+}

 'use strict';
+module.exports = function isCancel(value) {
+export default function isCancel(value) {
   return !!(value && value.__CANCEL__);
+};
+}

 '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;
+    /**
+    * 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);
+          href = urlParsingNode.href;
+        }
+      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;
+    };
+  })();

 'use strict';
+var utils = require('../utils');
+import utils from '../utils.js';
 /**
  * Config-specific merge-function which creates a new config-object
+ *
  * @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)) {
       return utils.merge(target, source);
+    } else if (utils.isEmptyObject(source)) {
+      return utils.merge({}, target);
     } else if (utils.isPlainObject(source)) {
       return utils.merge({}, source);
     } else if (utils.isArray(source)) {
+    }
+  }
+  var mergeMap = {
+  const mergeMap = {
     'url': valueFromConfig2,
     'method': valueFromConfig2,
     'data': valueFromConfig2,
     'timeout': defaultToConfig2,
     'timeoutMessage': defaultToConfig2,
     'withCredentials': defaultToConfig2,
+    'withXSRFToken': defaultToConfig2,
     'adapter': defaultToConfig2,
     'responseType': defaultToConfig2,
     'xsrfCookieName': defaultToConfig2,
   };
   utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
+    if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') {
+      return;
+    }
+    var merge = utils.hasOwnProperty(mergeMap, prop) ? 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;
+};
+}

Comparingaxios@0.30.3

Comparingaxios@0.30.3

Source

npm diff

Options

Bundlephobia

Packagephobia

Packagephobia

+++0---0

Packagephobia

LICENSE +++4---16

dist/axios.js +++1532---1005

dist/esm/axios.js +++1450---894

lib/axios.js +++33---25

lib/core/Axios.js +++124---112

lib/core/AxiosError.js +++10---7

lib/helpers/AxiosURLSearchParams.js +++22---6

lib/helpers/bind.js +++2---2

lib/core/buildFullPath.js +++5---7

lib/helpers/buildURL.js +++20---19

lib/cancel/CanceledError.js +++5---4

lib/cancel/CancelToken.js +++90---87

bin/check-build-version.js +++0---19

lib/helpers/combineURLs.js +++4---3

lib/helpers/cookies.js +++40---41

lib/env/data.js +++1---3

lib/helpers/deprecatedMethod.js +++4---2

lib/core/dispatchRequest.js +++21---39

lib/helpers/estimateDataURLDecodedBytes.js +++0---79

lib/env/classes/FormData.js +++2---2

lib/platform/browser/classes/FormData.js +++1---1

lib/platform/node/classes/FormData.js +++2---2

lib/helpers/formDataToJSON.js +++36---18

lib/helpers/fromDataURI.js +++15---13

lib/adapters/http.js +++250---146

index.js +++2---1

lib/defaults/index.js +++48---38

lib/platform/browser/index.js +++37---5

lib/platform/index.js +++2---2

lib/platform/node/index.js +++5---4

lib/core/InterceptorManager.js +++61---53

lib/helpers/isAbsoluteURL.js +++3---2

lib/helpers/isAxiosError.js +++4---3

lib/cancel/isCancel.js +++2---2

lib/helpers/isURLSameOrigin.js +++55---56

lib/core/mergeConfig.js +++8---13

lib/helpers/normalizeHeaderName.js +++0---12

lib/helpers/null.js +++1---1

lib/helpers/parseHeaders.js +++24---22

lib/helpers/parseProtocol.js +++3---3

rollup.config.js +++36---6

lib/core/settle.js +++6---4

lib/helpers/spread.js +++3---2

bin/ssl_hotfix.js +++1---1

lib/helpers/toFormData.js +++69---19

lib/helpers/toURLEncodedForm.js +++5---5

lib/core/transformData.js +++15---10

lib/defaults/transitional.js +++1---1

lib/platform/browser/classes/URLSearchParams.js +++2---3

lib/platform/node/classes/URLSearchParams.js +++2---3

lib/utils.js +++292---205

lib/helpers/validator.js +++20---15

lib/adapters/xhr.js +++79---59

package.json +++58---25

CHANGELOG.md +++163---1021

README.md +++32---24

SECURITY.md +++3---2

UPGRADE_GUIDE.md +++1---188

mise.toml +++0---2

index.d.ts +++207---71

dist/node/axios.cjs +++3750---0

karma.conf.cjs +++250---0

lib/core/AxiosHeaders.js +++274---0

lib/helpers/AxiosTransformStream.js +++191---0

gulpfile.js +++88---0

lib/adapters/index.js +++33---0

lib/helpers/speedometer.js +++55---0

lib/helpers/throttle.js +++33---0

Source

Comparing
`axios@0.30.3`

Comparing
`axios@0.30.3`

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

 '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
  * 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;
+export default rawHeaders => {
+  const parsed = {};
+  let key;
+  let val;
+  let i;
+  if (!headers) { return parsed; }
+  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;
+    }
   });

 '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] || '';
+};
+}

 import commonjs from '@rollup/plugin-commonjs';
 import {terser} from "rollup-plugin-terser";
 import json from '@rollup/plugin-json';
+import { babel } from '@rollup/plugin-babel';
+import autoExternal from 'rollup-plugin-auto-external';
+import bundleSize from 'rollup-plugin-bundle-size'
 const lib = require("./package.json");
 const outputFileName = 'axios';
 const name = "axios";
 const input = './lib/axios.js';
+const buildConfig = (config) => {
+const buildConfig = ({es5, browser = true, minifiedVersion = true, ...config}) => {
   const build = ({minified}) => ({
     input,
     },
     plugins: [
       json(),
+      resolve({browser: true}),
+      resolve({browser}),
       commonjs(),
       minified && terser(),
+      minified && bundleSize(),
+      ...(es5 ? [babel({
+        babelHelpers: 'bundled',
+        presets: ['@babel/preset-env']
+      })] : []),
       ...(config.plugins || []),
+    ]
   });
+  return [
+  const configs = [
     build({minified: false}),
+    build({minified: true}),
   ];
+  if (minifiedVersion) {
+    configs.push(build({minified: true}))
+  }
+  return configs;
 };
 export default async () => {
   const year = new Date().getFullYear();
+  const banner = `// ${lib.name} v${lib.version} Copyright (c) ${year} ${lib.author}`;
+  const banner = `// Axios v${lib.version} Copyright (c) ${year} ${lib.author} and contributors`;
   return [
     ...buildConfig({
+      es5: true,
       output: {
         file: `dist/${outputFileName}`,
         name,
         exports: "named",
         banner
+      }
+    })
+    }),
+    // Node.js commonjs build
+    {
+      input,
+      output: {
+        file: `dist/node/${name}.cjs`,
+        format: "cjs",
+        preferConst: true,
+        exports: "default",
+        banner
+      },
+      plugins: [
+        autoExternal(),
+        resolve(),
+        commonjs()
+      ]
+    }
+  ]
 };

 'use strict';
+var AxiosError = require('./AxiosError');
+import AxiosError from './AxiosError.js';
 /**
  * Resolve or reject a Promise based on response status.
  * @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 {
       response
     ));
+  }
+};
+}

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

+const {spawn} = require('child_process');
+import {spawn} from 'child_process';
 const args = process.argv.slice(2);

 '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)) {
       return helpers.defaultVisitor.apply(this, arguments);
+    }
   }, options));
+};
+}

 '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;
+};
+}

 '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;