axios 1.1.3 → 1.2.0

package/index.d.cts

@@ -0,0 +1,490 @@
+type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;
+type RawAxiosHeaders = Record<string, AxiosHeaderValue>;
+
+type MethodsHeaders = {
+  [Key in axios.Method as Lowercase<Key>]: AxiosHeaders;
+};
+
+interface CommonHeaders  {
+  common: AxiosHeaders;
+}
+
+type AxiosHeaderMatcher = (this: AxiosHeaders, value: string, name: string, headers: RawAxiosHeaders) => boolean;
+
+type AxiosHeaderSetter = (value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher) => AxiosHeaders;
+
+type AxiosHeaderGetter = ((parser?: RegExp) => RegExpExecArray | null) |
+    ((matcher?: AxiosHeaderMatcher) => AxiosHeaderValue);
+
+type AxiosHeaderTester = (matcher?: AxiosHeaderMatcher) => boolean;
+
+type MaxUploadRate = number;
+
+type MaxDownloadRate = number;
+
+type Milliseconds = number;
+
+declare class AxiosHeaders {
+  constructor(
+      headers?: RawAxiosHeaders | AxiosHeaders,
+      defaultHeaders?: RawAxiosHeaders | AxiosHeaders
+  );
+
+  set(headerName?: string, value?: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
+  set(headers?: RawAxiosHeaders | AxiosHeaders, rewrite?: boolean): AxiosHeaders;
+
+  get(headerName: string, parser: RegExp): RegExpExecArray | null;
+  get(headerName: string, matcher?: true | AxiosHeaderMatcher): AxiosHeaderValue;
+
+  has(header: string, matcher?: true | AxiosHeaderMatcher): boolean;
+
+  delete(header: string | string[], matcher?: AxiosHeaderMatcher): boolean;
+
+  clear(): boolean;
+
+  normalize(format: boolean): AxiosHeaders;
+
+  toJSON(asStrings?: boolean): RawAxiosHeaders;
+
+  static from(thing?: AxiosHeaders | RawAxiosHeaders | string): AxiosHeaders;
+
+  static accessor(header: string | string[]): AxiosHeaders;
+
+  setContentType: AxiosHeaderSetter;
+  getContentType: AxiosHeaderGetter;
+  hasContentType: AxiosHeaderTester;
+
+  setContentLength: AxiosHeaderSetter;
+  getContentLength: AxiosHeaderGetter;
+  hasContentLength: AxiosHeaderTester;
+
+  setAccept: AxiosHeaderSetter;
+  getAccept: AxiosHeaderGetter;
+  hasAccept: AxiosHeaderTester;
+
+  setUserAgent: AxiosHeaderSetter;
+  getUserAgent: AxiosHeaderGetter;
+  hasUserAgent: AxiosHeaderTester;
+
+  setContentEncoding: AxiosHeaderSetter;
+  getContentEncoding: AxiosHeaderGetter;
+  hasContentEncoding: AxiosHeaderTester;
+}
+
+declare class AxiosError<T = unknown, D = any> extends Error {
+  constructor(
+      message?: string,
+      code?: string,
+      config?: axios.AxiosRequestConfig<D>,
+      request?: any,
+      response?: axios.AxiosResponse<T, D>
+  );
+
+  config?: axios.AxiosRequestConfig<D>;
+  code?: string;
+  request?: any;
+  response?: axios.AxiosResponse<T, D>;
+  isAxiosError: boolean;
+  status?: number;
+  toJSON: () => object;
+  cause?: Error;
+  static readonly ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
+  static readonly ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
+  static readonly ERR_BAD_OPTION = "ERR_BAD_OPTION";
+  static readonly ERR_NETWORK = "ERR_NETWORK";
+  static readonly ERR_DEPRECATED = "ERR_DEPRECATED";
+  static readonly ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
+  static readonly ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
+  static readonly ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
+  static readonly ERR_INVALID_URL = "ERR_INVALID_URL";
+  static readonly ERR_CANCELED = "ERR_CANCELED";
+  static readonly ECONNABORTED = "ECONNABORTED";
+  static readonly ETIMEDOUT = "ETIMEDOUT";
+}
+
+declare class CanceledError<T> extends AxiosError<T> {
+}
+
+declare class Axios {
+  constructor(config?: axios.AxiosRequestConfig);
+  defaults: axios.AxiosDefaults;
+  interceptors: {
+    request: axios.AxiosInterceptorManager<axios.AxiosRequestConfig>;
+    response: axios.AxiosInterceptorManager<axios.AxiosResponse>;
+  };
+  getUri(config?: axios.AxiosRequestConfig): string;
+  request<T = any, R = axios.AxiosResponse<T>, D = any>(config: axios.AxiosRequestConfig<D>): Promise<R>;
+  get<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+  delete<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+  head<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+  options<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+  post<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+  put<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+  patch<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+  postForm<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+  putForm<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+  patchForm<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
+}
+
+declare enum HttpStatusCode {
+  Continue = 100,
+  SwitchingProtocols = 101,
+  Processing = 102,
+  EarlyHints = 103,
+  Ok = 200,
+  Created = 201,
+  Accepted = 202,
+  NonAuthoritativeInformation = 203,
+  NoContent = 204,
+  ResetContent = 205,
+  PartialContent = 206,
+  MultiStatus = 207,
+  AlreadyReported = 208,
+  ImUsed = 226,
+  MultipleChoices = 300,
+  MovedPermanently = 301,
+  Found = 302,
+  SeeOther = 303,
+  NotModified = 304,
+  UseProxy = 305,
+  Unused = 306,
+  TemporaryRedirect = 307,
+  PermanentRedirect = 308,
+  BadRequest = 400,
+  Unauthorized = 401,
+  PaymentRequired = 402,
+  Forbidden = 403,
+  NotFound = 404,
+  MethodNotAllowed = 405,
+  NotAcceptable = 406,
+  ProxyAuthenticationRequired = 407,
+  RequestTimeout = 408,
+  Conflict = 409,
+  Gone = 410,
+  LengthRequired = 411,
+  PreconditionFailed = 412,
+  PayloadTooLarge = 413,
+  UriTooLong = 414,
+  UnsupportedMediaType = 415,
+  RangeNotSatisfiable = 416,
+  ExpectationFailed = 417,
+  ImATeapot = 418,
+  MisdirectedRequest = 421,
+  UnprocessableEntity = 422,
+  Locked = 423,
+  FailedDependency = 424,
+  TooEarly = 425,
+  UpgradeRequired = 426,
+  PreconditionRequired = 428,
+  TooManyRequests = 429,
+  RequestHeaderFieldsTooLarge = 431,
+  UnavailableForLegalReasons = 451,
+  InternalServerError = 500,
+  NotImplemented = 501,
+  BadGateway = 502,
+  ServiceUnavailable = 503,
+  GatewayTimeout = 504,
+  HttpVersionNotSupported = 505,
+  VariantAlsoNegotiates = 506,
+  InsufficientStorage = 507,
+  LoopDetected = 508,
+  NotExtended = 510,
+  NetworkAuthenticationRequired = 511,
+}
+
+type InternalAxiosError<T = unknown, D = any> = AxiosError<T, D>;
+
+declare namespace axios {
+  type AxiosError<T = unknown, D = any> = InternalAxiosError<T, D>;
+
+  type RawAxiosRequestHeaders = Partial<RawAxiosHeaders & MethodsHeaders & CommonHeaders>;
+
+  type AxiosRequestHeaders = Partial<RawAxiosHeaders & MethodsHeaders & CommonHeaders> & AxiosHeaders;
+
+  type RawAxiosResponseHeaders = Partial<Record<string, string> & {
+    "set-cookie"?: string[]
+  }>;
+
+  type AxiosResponseHeaders = RawAxiosResponseHeaders & AxiosHeaders;
+
+  interface AxiosRequestTransformer {
+    (this: AxiosRequestConfig, data: any, headers: AxiosRequestHeaders): any;
+  }
+
+  interface AxiosResponseTransformer {
+    (this: AxiosRequestConfig, data: any, headers: AxiosResponseHeaders, status?: number): any;
+  }
+
+  interface AxiosAdapter {
+    (config: AxiosRequestConfig): AxiosPromise;
+  }
+
+  interface AxiosBasicCredentials {
+    username: string;
+    password: string;
+  }
+
+  interface AxiosProxyConfig {
+    host: string;
+    port: number;
+    auth?: {
+      username: string;
+      password: string;
+    };
+    protocol?: string;
+  }
+
+  type Method =
+    | 'get' | 'GET'
+    | 'delete' | 'DELETE'
+    | 'head' | 'HEAD'
+    | 'options' | 'OPTIONS'
+    | 'post' | 'POST'
+    | 'put' | 'PUT'
+    | 'patch' | 'PATCH'
+    | 'purge' | 'PURGE'
+    | 'link' | 'LINK'
+    | 'unlink' | 'UNLINK';
+
+  type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  type responseEncoding =
+    | 'ascii' | 'ASCII'
+    | 'ansi' | 'ANSI'
+    | 'binary' | 'BINARY'
+    | 'base64' | 'BASE64'
+    | 'base64url' | 'BASE64URL'
+    | 'hex' | 'HEX'
+    | 'latin1' | 'LATIN1'
+    | 'ucs-2' | 'UCS-2'
+    | 'ucs2' | 'UCS2'
+    | 'utf-8' | 'UTF-8'
+    | 'utf8' | 'UTF8'
+    | 'utf16le' | 'UTF16LE';
+
+  interface TransitionalOptions {
+    silentJSONParsing?: boolean;
+    forcedJSONParsing?: boolean;
+    clarifyTimeoutError?: boolean;
+  }
+
+  interface GenericAbortSignal {
+    readonly aborted: boolean;
+    onabort?: ((...args: any) => any) | null;
+    addEventListener?: (...args: any) => any;
+    removeEventListener?: (...args: any) => any;
+  }
+
+  interface FormDataVisitorHelpers {
+    defaultVisitor: SerializerVisitor;
+    convertValue: (value: any) => any;
+    isVisitable: (value: any) => boolean;
+  }
+
+  interface SerializerVisitor {
+    (
+        this: GenericFormData,
+        value: any,
+        key: string | number,
+        path: null | Array<string | number>,
+        helpers: FormDataVisitorHelpers
+    ): boolean;
+  }
+
+  interface SerializerOptions {
+    visitor?: SerializerVisitor;
+    dots?: boolean;
+    metaTokens?: boolean;
+    indexes?: boolean | null;
+  }
+
+  // tslint:disable-next-line
+  interface FormSerializerOptions extends SerializerOptions {
+  }
+
+  interface ParamEncoder {
+    (value: any, defaultEncoder: (value: any) => any): any;
+  }
+
+  interface CustomParamsSerializer {
+    (params: Record<string, any>, options?: ParamsSerializerOptions): string;
+  }
+
+  interface ParamsSerializerOptions extends SerializerOptions {
+    encode?: ParamEncoder;
+    serialize?: CustomParamsSerializer;
+  }
+
+  interface AxiosProgressEvent {
+    loaded: number;
+    total?: number;
+    progress?: number;
+    bytes: number;
+    rate?: number;
+    estimated?: number;
+    upload?: boolean;
+    download?: boolean;
+  }
+
+  interface AxiosRequestConfig<D = any> {
+    url?: string;
+    method?: Method | string;
+    baseURL?: string;
+    transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];
+    transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[];
+    headers?: RawAxiosRequestHeaders;
+    params?: any;
+    paramsSerializer?: ParamsSerializerOptions;
+    data?: D;
+    timeout?: Milliseconds;
+    timeoutErrorMessage?: string;
+    withCredentials?: boolean;
+    adapter?: AxiosAdapter;
+    auth?: AxiosBasicCredentials;
+    responseType?: ResponseType;
+    responseEncoding?: responseEncoding | string;
+    xsrfCookieName?: string;
+    xsrfHeaderName?: string;
+    onUploadProgress?: (progressEvent: AxiosProgressEvent) => void;
+    onDownloadProgress?: (progressEvent: AxiosProgressEvent) => void;
+    maxContentLength?: number;
+    validateStatus?: ((status: number) => boolean) | null;
+    maxBodyLength?: number;
+    maxRedirects?: number;
+    maxRate?: number | [MaxUploadRate, MaxDownloadRate];
+    beforeRedirect?: (options: Record<string, any>, responseDetails: {headers: Record<string, string>}) => void;
+    socketPath?: string | null;
+    httpAgent?: any;
+    httpsAgent?: any;
+    proxy?: AxiosProxyConfig | false;
+    cancelToken?: CancelToken;
+    decompress?: boolean;
+    transitional?: TransitionalOptions;
+    signal?: GenericAbortSignal;
+    insecureHTTPParser?: boolean;
+    env?: {
+      FormData?: new (...args: any[]) => object;
+    };
+    formSerializer?: FormSerializerOptions;
+  }
+
+  interface HeadersDefaults {
+    common: RawAxiosRequestHeaders;
+    delete: RawAxiosRequestHeaders;
+    get: RawAxiosRequestHeaders;
+    head: RawAxiosRequestHeaders;
+    post: RawAxiosRequestHeaders;
+    put: RawAxiosRequestHeaders;
+    patch: RawAxiosRequestHeaders;
+    options?: RawAxiosRequestHeaders;
+    purge?: RawAxiosRequestHeaders;
+    link?: RawAxiosRequestHeaders;
+    unlink?: RawAxiosRequestHeaders;
+  }
+
+  interface AxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
+    headers: HeadersDefaults;
+  }
+
+  interface CreateAxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
+    headers?: RawAxiosRequestHeaders | Partial<HeadersDefaults>;
+  }
+
+  interface AxiosResponse<T = any, D = any>  {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: RawAxiosResponseHeaders | AxiosResponseHeaders;
+    config: AxiosRequestConfig<D>;
+    request?: any;
+  }
+
+  type AxiosPromise<T = any> = Promise<AxiosResponse<T>>;
+
+  interface CancelStatic {
+    new (message?: string): Cancel;
+  }
+
+  interface Cancel {
+    message: string | undefined;
+  }
+
+  interface Canceler {
+    (message?: string, config?: AxiosRequestConfig, request?: any): void;
+  }
+
+  interface CancelTokenStatic {
+    new (executor: (cancel: Canceler) => void): CancelToken;
+    source(): CancelTokenSource;
+  }
+
+  interface CancelToken {
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+
+  interface CancelTokenSource {
+    token: CancelToken;
+    cancel: Canceler;
+  }
+
+  interface AxiosInterceptorOptions {
+    synchronous?: boolean;
+    runWhen?: (config: AxiosRequestConfig) => boolean;
+  }
+
+  interface AxiosInterceptorManager<V> {
+    use(onFulfilled?: (value: V) => V | Promise<V>, onRejected?: (error: any) => any, options?: AxiosInterceptorOptions): number;
+    eject(id: number): void;
+    clear(): void;
+  }
+
+  interface AxiosInstance extends Axios {
+    <T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
+    <T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
+
+    defaults: Omit<AxiosDefaults, 'headers'> & {
+      headers: HeadersDefaults & {
+        [key: string]: AxiosHeaderValue
+      }
+    };
+  }
+
+  interface GenericFormData {
+    append(name: string, value: any, options?: any): any;
+  }
+
+  interface GenericHTMLFormElement {
+    name: string;
+    method: string;
+    submit(): void;
+  }
+
+  interface AxiosStatic extends AxiosInstance {
+    create(config?: CreateAxiosDefaults): AxiosInstance;
+    Cancel: CancelStatic;
+    CancelToken: CancelTokenStatic;
+    Axios: typeof Axios;
+    AxiosError: typeof AxiosError;
+    CanceledError: typeof CanceledError;
+    HttpStatusCode: typeof HttpStatusCode;
+    readonly VERSION: string;
+    isCancel(value: any): value is Cancel;
+    all<T>(values: Array<T | Promise<T>>): Promise<T[]>;
+    spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
+    isAxiosError<T = any, D = any>(payload: any): payload is AxiosError<T, D>;
+    toFormData(sourceObj: object, targetFormData?: GenericFormData, options?: FormSerializerOptions): GenericFormData;
+    formToJSON(form: GenericFormData|GenericHTMLFormElement): object;
+  }
+}
+
+declare const axios: axios.AxiosStatic;
+
+export = axios;

package/index.d.ts

@@ -1,4 +1,4 @@
-// TypeScript Version: 4.1
+// TypeScript Version: 4.7
 type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;
 type RawAxiosHeaders = Record<string, AxiosHeaderValue>;
 
@@ -21,8 +21,7 @@ type AxiosHeaderTester = (matcher?: AxiosHeaderMatcher) => boolean;
 
 export class AxiosHeaders {
   constructor(
-      headers?: RawAxiosHeaders | AxiosHeaders,
-      defaultHeaders?: RawAxiosHeaders | AxiosHeaders
+      headers?: RawAxiosHeaders | AxiosHeaders
   );
 
   set(headerName?: string, value?: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
@@ -39,12 +38,16 @@ export class AxiosHeaders {
 
   normalize(format: boolean): AxiosHeaders;
 
+  concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string>): AxiosHeaders;
+
   toJSON(asStrings?: boolean): RawAxiosHeaders;
 
   static from(thing?: AxiosHeaders | RawAxiosHeaders | string): AxiosHeaders;
 
   static accessor(header: string | string[]): AxiosHeaders;
 
+  static concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string>): AxiosHeaders;
+
   setContentType: AxiosHeaderSetter;
   getContentType: AxiosHeaderGetter;
   hasContentType: AxiosHeaderTester;
@@ -269,10 +272,15 @@ export interface AxiosProgressEvent {
   estimated?: number;
   upload?: boolean;
   download?: boolean;
+  event?: ProgressEvent;
 }
 
 type Milliseconds = number;
 
+type AxiosAdapterName = 'xhr' | 'http' | string;
+
+type AxiosAdapterConfig = AxiosAdapter | AxiosAdapterName;
+
 export interface AxiosRequestConfig<D = any> {
   url?: string;
   method?: Method | string;
@@ -286,7 +294,7 @@ export interface AxiosRequestConfig<D = any> {
   timeout?: Milliseconds;
   timeoutErrorMessage?: string;
   withCredentials?: boolean;
-  adapter?: AxiosAdapter;
+  adapter?: AxiosAdapterConfig | AxiosAdapterConfig[];
   auth?: AxiosBasicCredentials;
   responseType?: ResponseType;
   responseEncoding?: responseEncoding | string;
@@ -416,7 +424,7 @@ export interface AxiosInterceptorOptions {
 }
 
 export interface AxiosInterceptorManager<V> {
-  use(onFulfilled?: (value: V) => V | Promise<V>, onRejected?: (error: any) => any, options?: AxiosInterceptorOptions): number;
+  use(onFulfilled?: ((value: V) => V | Promise<V>) | null, onRejected?: ((error: any) => any) | null, options?: AxiosInterceptorOptions): number;
   eject(id: number): void;
   clear(): void;
 }
@@ -463,6 +471,18 @@ export interface GenericHTMLFormElement {
   submit(): void;
 }
 
+export function toFormData(sourceObj: object, targetFormData?: GenericFormData, options?: FormSerializerOptions): GenericFormData;
+
+export function formToJSON(form: GenericFormData|GenericHTMLFormElement): object;
+
+export function isAxiosError<T = any, D = any>(payload: any): payload is AxiosError<T, D>;
+
+export function spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
+
+export function isCancel(value: any): value is Cancel;
+
+export function all<T>(values: Array<T | Promise<T>>): Promise<T[]>;
+
 export interface AxiosStatic extends AxiosInstance {
   create(config?: CreateAxiosDefaults): AxiosInstance;
   Cancel: CancelStatic;
@@ -470,12 +490,14 @@ export interface AxiosStatic extends AxiosInstance {
   Axios: typeof Axios;
   AxiosError: typeof AxiosError;
   readonly VERSION: string;
-  isCancel(value: any): value is Cancel;
-  all<T>(values: Array<T | Promise<T>>): Promise<T[]>;
-  spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
-  isAxiosError<T = any, D = any>(payload: any): payload is AxiosError<T, D>;
-  toFormData(sourceObj: object, targetFormData?: GenericFormData, options?: FormSerializerOptions): GenericFormData;
-  formToJSON(form: GenericFormData|GenericHTMLFormElement): object;
+  isCancel: typeof isCancel;
+  all: typeof all;
+  spread: typeof spread;
+  isAxiosError: typeof isAxiosError;
+  toFormData: typeof toFormData;
+  formToJSON: typeof formToJSON;
+  CanceledError: typeof CanceledError;
+  AxiosHeaders: typeof AxiosHeaders;
 }
 
 declare const axios: AxiosStatic;

package/index.js

@@ -1,5 +1,6 @@
 import axios from './lib/axios.js';
 
+// This module is intended to unwrap Axios default export as named.
 // Keep top-level export same with static properties
 // so that it can keep same with es module or cjs
 const {
@@ -13,11 +14,13 @@ const {
   Cancel,
   isAxiosError,
   spread,
-  toFormData
+  toFormData,
+  AxiosHeaders,
+  formToJSON
 } = axios;
 
-export default axios;
 export {
+  axios as default,
   Axios,
   AxiosError,
   CanceledError,
@@ -28,5 +31,7 @@ export {
   Cancel,
   isAxiosError,
   spread,
-  toFormData
+  toFormData,
+  AxiosHeaders,
+  formToJSON
 }

package/karma.conf.cjs

@@ -129,7 +129,7 @@ module.exports = function(config) {
     );
     browsers = ['Firefox'];
   } else if (process.env.GITHUB_ACTIONS === 'true') {
-    console.log('Running ci on Github Actions.');
+    console.log('Running ci on GitHub Actions.');
     browsers = ['FirefoxHeadless', 'ChromeHeadless'];
   } else {
     browsers = browsers || ['Chrome'];

package/lib/adapters/adapters.js

@@ -0,0 +1,59 @@
+import utils from '../utils.js';
+import httpAdapter from './http.js';
+import xhrAdapter from './xhr.js';
+import AxiosError from "../core/AxiosError.js";
+
+const knownAdapters = {
+  http: httpAdapter,
+  xhr: xhrAdapter
+}
+
+utils.forEach(knownAdapters, (fn, value) => {
+  if(fn) {
+    try {
+      Object.defineProperty(fn, 'name', {value});
+    } catch (e) {
+      // eslint-disable-next-line no-empty
+    }
+    Object.defineProperty(fn, 'adapterName', {value});
+  }
+});
+
+export default {
+  getAdapter: (adapters) => {
+    adapters = utils.isArray(adapters) ? adapters : [adapters];
+
+    const {length} = adapters;
+    let nameOrAdapter;
+    let adapter;
+
+    for (let i = 0; i < length; i++) {
+      nameOrAdapter = adapters[i];
+      if((adapter = utils.isString(nameOrAdapter) ? knownAdapters[nameOrAdapter.toLowerCase()] : nameOrAdapter)) {
+        break;
+      }
+    }
+
+    if (!adapter) {
+      if (adapter === false) {
+        throw new AxiosError(
+          `Adapter ${nameOrAdapter} is not supported by the environment`,
+          'ERR_NOT_SUPPORT'
+        );
+      }
+
+      throw new Error(
+        utils.hasOwnProp(knownAdapters, nameOrAdapter) ?
+          `Adapter '${nameOrAdapter}' is not available in the build` :
+          `Unknown adapter '${nameOrAdapter}'`
+      );
+    }
+
+    if (!utils.isFunction(adapter)) {
+      throw new TypeError('adapter is not a function');
+    }
+
+    return adapter;
+  },
+  adapters: knownAdapters
+}