@taquito/http-utils 17.4.0 → 17.5.0-beta-RC.0

package/dist/lib/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpResponseError = exports.HttpRequestFailed = void 0;
+exports.HttpTimeoutError = exports.HttpResponseError = exports.HttpRequestFailed = void 0;
 const core_1 = require("@taquito/core");
 /**
  *  @category Error
@@ -29,7 +29,21 @@ class HttpResponseError extends core_1.NetworkError {
         this.statusText = statusText;
         this.body = body;
         this.url = url;
-        this.name = 'HttpResponse';
+        this.name = 'HttpResponseError';
     }
 }
 exports.HttpResponseError = HttpResponseError;
+/**
+ *  @category Error
+ *  @description Error
+ */
+class HttpTimeoutError extends core_1.NetworkError {
+    constructor(timeout, url) {
+        super();
+        this.timeout = timeout;
+        this.url = url;
+        this.name = 'HttpTimeoutError';
+        this.message = `HTTP request timeout of ${timeout}ms exceeded`;
+    }
+}
+exports.HttpTimeoutError = HttpTimeoutError;

package/dist/lib/taquito-http-utils.js

@@ -28,23 +28,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpBackend = exports.HttpResponseError = exports.HttpRequestFailed = exports.VERSION = void 0;
-const fetch_adapter_1 = require("./fetch-adapter");
-const axios_1 = require("axios");
-const errors_1 = require("./errors");
+exports.HttpBackend = exports.HttpTimeoutError = exports.HttpResponseError = exports.HttpRequestFailed = exports.VERSION = void 0;
+let fetch = globalThis === null || globalThis === void 0 ? void 0 : globalThis.fetch;
+// Will only use browser fetch if we are in a browser environment,
+// default to the more stable node-fetch otherwise
 const isNode = typeof process !== 'undefined' && !!((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node);
-const adapter = isNode ? undefined : fetch_adapter_1.default;
+if (isNode) {
+    fetch = require('node-fetch');
+}
+const errors_1 = require("./errors");
 __exportStar(require("./status_code"), exports);
 var version_1 = require("./version");
 Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
 var errors_2 = require("./errors");
 Object.defineProperty(exports, "HttpRequestFailed", { enumerable: true, get: function () { return errors_2.HttpRequestFailed; } });
 Object.defineProperty(exports, "HttpResponseError", { enumerable: true, get: function () { return errors_2.HttpResponseError; } });
-var ResponseType;
-(function (ResponseType) {
-    ResponseType["TEXT"] = "text";
-    ResponseType["JSON"] = "json";
-})(ResponseType || (ResponseType = {}));
+Object.defineProperty(exports, "HttpTimeoutError", { enumerable: true, get: function () { return errors_2.HttpTimeoutError; } });
 class HttpBackend {
     constructor(timeout = 30000) {
         this.timeout = timeout;
@@ -86,51 +85,55 @@ class HttpBackend {
     /**
      *
      * @param options contains options to be passed for the HTTP request (url, method and timeout)
-     * @throws {@link HttpRequestFailed} | {@link HttpResponseError}
+     * @throws {@link HttpRequestFailed} | {@link HttpResponseError} | {@link HttpTimeoutError}
      */
     createRequest({ url, method, timeout = this.timeout, query, headers = {}, json = true }, data) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Serializes query params
             const urlWithQuery = url + this.serialize(query);
-            let resType;
-            let transformResponse = undefined;
+            // Adds default header entry if there aren't any Content-Type header
             if (!headers['Content-Type']) {
                 headers['Content-Type'] = 'application/json';
             }
-            if (!json) {
-                resType = ResponseType.TEXT;
-                transformResponse = [(v) => v];
-            }
-            else {
-                resType = ResponseType.JSON;
-            }
+            // Creates a new AbortController instance to handle timeouts
+            const controller = new AbortController();
+            const t = setTimeout(() => controller.abort(), timeout);
             try {
-                const response = yield axios_1.default.request({
-                    url: urlWithQuery,
-                    method: method !== null && method !== void 0 ? method : 'GET',
-                    headers: headers,
-                    responseType: resType,
-                    transformResponse,
-                    timeout: timeout,
-                    data: data,
-                    adapter,
+                const response = yield fetch(urlWithQuery, {
+                    method,
+                    headers,
+                    body: JSON.stringify(data),
+                    signal: controller.signal,
                 });
-                return response.data;
+                if (typeof response === 'undefined') {
+                    throw new Error('Response is undefined');
+                }
+                // Handle responses with status code >= 400
+                if (response.status >= 400) {
+                    const errorData = yield response.text();
+                    throw new errors_1.HttpResponseError(`Http error response: (${response.status}) ${errorData}`, response.status, response.statusText, errorData, urlWithQuery);
+                }
+                if (json) {
+                    return response.json();
+                }
+                else {
+                    return response.text();
+                }
             }
-            catch (err) {
-                if ((axios_1.default.isAxiosError(err) && err.response) || (!isNode && err.response)) {
-                    let errorData;
-                    if (typeof err.response.data === 'object') {
-                        errorData = JSON.stringify(err.response.data);
-                    }
-                    else {
-                        errorData = err.response.data;
-                    }
-                    throw new errors_1.HttpResponseError(`Http error response: (${err.response.status}) ${errorData}`, err.response.status, err.response.statusText, errorData, urlWithQuery);
+            catch (e) {
+                if (e instanceof Error && e.name === 'AbortError') {
+                    throw new errors_1.HttpTimeoutError(timeout, urlWithQuery);
+                }
+                else if (e instanceof errors_1.HttpResponseError) {
+                    throw e;
                 }
                 else {
-                    throw new errors_1.HttpRequestFailed(String(method), urlWithQuery, err);
+                    throw new errors_1.HttpRequestFailed(String(method), urlWithQuery, e);
                 }
             }
+            finally {
+                clearTimeout(t);
+            }
         });
     }
 }

package/dist/lib/version.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 exports.VERSION = {
-    "commitHash": "a908ab176a8c52c025fd43e7acd452415396f54e",
-    "version": "17.4.0"
+    "commitHash": "f6fd420c519d8d104ce768b53626f6033ecf4cd3",
+    "version": "17.5.0-beta-RC.0"
 };

package/dist/taquito-http-utils.es6.js

@@ -1,4 +1,3 @@
-import axios from 'axios';
 import { NetworkError } from '@taquito/core';
 
 /******************************************************************************
@@ -33,223 +32,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const settle = require('axios/lib/core/settle');
-const buildURL = require('axios/lib/helpers/buildURL');
-const buildFullPath = require('axios/lib/core/buildFullPath');
-const { isUndefined, isStandardBrowserEnv, isFormData } = require('axios/lib/utils');
-/**
- * - Create a request object
- * - Get response body
- * - Check if timeout
- */
-function fetchAdapter(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const request = createRequest(config);
-        const promiseChain = [getResponse(request, config)];
-        if (config.timeout && config.timeout > 0) {
-            promiseChain.push(new Promise((res) => {
-                setTimeout(() => {
-                    const message = config.timeoutErrorMessage
-                        ? config.timeoutErrorMessage
-                        : 'timeout of ' + config.timeout + 'ms exceeded';
-                    res(createError(message, config, 'ECONNABORTED', request));
-                }, config.timeout);
-            }));
-        }
-        const data = yield Promise.race(promiseChain);
-        return new Promise((resolve, reject) => {
-            if (data instanceof Error) {
-                reject(data);
-            }
-            else {
-                const c = config;
-                'settle' in c && Object.prototype.toString.call(c.settle) === '[object Function]'
-                    ? c.settle(resolve, reject, data)
-                    : settle(resolve, reject, data);
-            }
-        });
-    });
-}
-/**
- * Fetch API stage two is to get response body. This function tries to retrieve
- * response body based on response's type
- */
-function getResponse(request, config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const stageOne = yield fetch(request);
-            let response = {
-                ok: stageOne.ok,
-                status: stageOne.status,
-                statusText: stageOne.statusText,
-                headers: new Headers(stageOne.headers),
-                config: config,
-                request,
-            };
-            if (stageOne.status >= 400) {
-                return createError('Response Error', config, 'ERR_NETWORK', request, response);
-            }
-            response = {
-                ok: stageOne.ok,
-                status: stageOne.status,
-                statusText: stageOne.statusText,
-                headers: new Headers(stageOne.headers),
-                config: config,
-                request,
-            };
-            if (stageOne.status >= 200 && stageOne.status !== 204) {
-                switch (config.responseType) {
-                    case 'arraybuffer':
-                        response.data = yield stageOne.arrayBuffer();
-                        break;
-                    case 'blob':
-                        response.data = yield stageOne.blob();
-                        break;
-                    case 'json':
-                        response.data = yield stageOne.json();
-                        break;
-                    // TODO: the next option does not exist in response type
-                    // case 'formData':
-                    //     response.data = await stageOne.formData();
-                    //     break;
-                    default:
-                        response.data = yield stageOne.text();
-                        break;
-                }
-            }
-            return response;
-        }
-        catch (e) {
-            return createError('Network Error', config, 'ERR_NETWORK', request);
-        }
-    });
-}
-/**
- * This function will create a Request object based on configuration's axios
- */
-function createRequest(config) {
-    var _a;
-    const headers = new Headers(config.headers);
-    // HTTP basic authentication
-    if (config.auth) {
-        const username = config.auth.username || '';
-        const password = config.auth.password
-            ? decodeURI(encodeURIComponent(config.auth.password))
-            : '';
-        headers.set('Authorization', `Basic ${btoa(username + ':' + password)}`);
-    }
-    const method = (_a = config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-    const options = {
-        headers: headers,
-        method,
-    };
-    if (method !== 'GET' && method !== 'HEAD') {
-        options.body = config.data;
-        // In these cases the browser will automatically set the correct Content-Type,
-        // but only if that header hasn't been set yet. So that's why we're deleting it.
-        if (isFormData(options.body) && isStandardBrowserEnv()) {
-            headers.delete('Content-Type');
-        }
-    }
-    const c = config;
-    if ('mode' in c) {
-        options.mode = c.mode;
-    }
-    if ('cache' in c) {
-        options.cache = c.cache;
-    }
-    if ('integrity' in c) {
-        options.integrity = c.integrity;
-    }
-    if ('redirect' in c) {
-        options.redirect = c.redirect;
-    }
-    if ('referrer' in c) {
-        options.referrer = c.referrer;
-    }
-    // This config is similar to XHR’s withCredentials flag, but with three available values instead of two.
-    // So if withCredentials is not set, default value 'same-origin' will be used
-    if (!isUndefined(c.withCredentials)) {
-        options.credentials = c.withCredentials ? 'include' : 'omit';
-    }
-    const fullPath = buildFullPath(c.baseURL, c.url);
-    const url = buildURL(fullPath, c.params, c.paramsSerializer);
-    // Expected browser to throw error if there is any wrong configuration value
-    return new Request(url, options);
-}
-/**
- * Note:
- *
- *   From version >= 0.27.0, createError function is replaced by AxiosError class.
- *   So I copy the old createError function here for backward compatible.
- *
- *
- *
- * Create an Error with the specified message, config, error code, request and response.
- *
- * @param {string} message The error message.
- * @param {Object} config The config.
- * @param {string} [code] The error code (for example, 'ECONNABORTED').
- * @param {Object} [request] The request.
- * @param {Object} [response] The response.
- * @returns {Error} The created error.
- */
-function createError(message, config, code, request, response) {
-    // TODO: this code never runs
-    // if ('AxiosError' in axios && axios.AxiosError && typeof axios.AxiosError === 'function' && isConstructor(axios.AxiosError)) {
-    //     return new axios.AxiosError(message, axios.AxiosError[code], config, request, response);
-    // }
-    const error = new Error(message);
-    return enhanceError(error, config, code, request, response);
-}
-/**
- *
- * Note:
- *
- *   This function is for backward compatible.
- *
- *
- * Update an Error with the specified config, error code, and response.
- *
- * @param {Error} error The error to update.
- * @param {Object} config The config.
- * @param {string} [code] The error code (for example, 'ECONNABORTED').
- * @param {Object} [request] The request.
- * @param {Object} [response] The response.
- * @returns {Error} The error.
- */
-function enhanceError(error, config, code, request, response) {
-    error.config = config;
-    if (code) {
-        error.code = code;
-    }
-    error.request = request;
-    error.response = response;
-    error.isAxiosError = true;
-    error.toJSON = function toJSON() {
-        return {
-            // Standard
-            message: this.message,
-            name: this.name,
-            // Microsoft
-            description: 'description' in this ? this.description : undefined,
-            number: 'number' in this ? this.number : undefined,
-            // Mozilla
-            fileName: 'fileName' in this ? this.fileName : undefined,
-            lineNumber: 'lineNumber' in this ? this.lineNumber : undefined,
-            columnNumber: 'columnNumber' in this ? this.columnNumber : undefined,
-            stack: this.stack,
-            // Axios
-            config: this.config,
-            code: this.code,
-            status: this.response && this.response.status ? this.response.status : null,
-        };
-    };
-    return error;
-}
-
 /**
  *  @category Error
  *  @description Error that indicates a general failure in making the HTTP request
@@ -276,7 +58,20 @@ class HttpResponseError extends NetworkError {
         this.statusText = statusText;
         this.body = body;
         this.url = url;
-        this.name = 'HttpResponse';
+        this.name = 'HttpResponseError';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error
+ */
+class HttpTimeoutError extends NetworkError {
+    constructor(timeout, url) {
+        super();
+        this.timeout = timeout;
+        this.url = url;
+        this.name = 'HttpTimeoutError';
+        this.message = `HTTP request timeout of ${timeout}ms exceeded`;
     }
 }
 
@@ -602,8 +397,8 @@ var STATUS_CODE;
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "a908ab176a8c52c025fd43e7acd452415396f54e",
-    "version": "17.4.0"
+    "commitHash": "f6fd420c519d8d104ce768b53626f6033ecf4cd3",
+    "version": "17.5.0-beta-RC.0"
 };
 
 /**
@@ -611,13 +406,13 @@ const VERSION = {
  * @module @taquito/http-utils
  */
 var _a;
+let fetch = globalThis === null || globalThis === void 0 ? void 0 : globalThis.fetch;
+// Will only use browser fetch if we are in a browser environment,
+// default to the more stable node-fetch otherwise
 const isNode = typeof process !== 'undefined' && !!((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node);
-const adapter = isNode ? undefined : fetchAdapter;
-var ResponseType;
-(function (ResponseType) {
-    ResponseType["TEXT"] = "text";
-    ResponseType["JSON"] = "json";
-})(ResponseType || (ResponseType = {}));
+if (isNode) {
+    fetch = require('node-fetch');
+}
 class HttpBackend {
     constructor(timeout = 30000) {
         this.timeout = timeout;
@@ -659,54 +454,58 @@ class HttpBackend {
     /**
      *
      * @param options contains options to be passed for the HTTP request (url, method and timeout)
-     * @throws {@link HttpRequestFailed} | {@link HttpResponseError}
+     * @throws {@link HttpRequestFailed} | {@link HttpResponseError} | {@link HttpTimeoutError}
      */
     createRequest({ url, method, timeout = this.timeout, query, headers = {}, json = true }, data) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Serializes query params
             const urlWithQuery = url + this.serialize(query);
-            let resType;
-            let transformResponse = undefined;
+            // Adds default header entry if there aren't any Content-Type header
             if (!headers['Content-Type']) {
                 headers['Content-Type'] = 'application/json';
             }
-            if (!json) {
-                resType = ResponseType.TEXT;
-                transformResponse = [(v) => v];
-            }
-            else {
-                resType = ResponseType.JSON;
-            }
+            // Creates a new AbortController instance to handle timeouts
+            const controller = new AbortController();
+            const t = setTimeout(() => controller.abort(), timeout);
             try {
-                const response = yield axios.request({
-                    url: urlWithQuery,
-                    method: method !== null && method !== void 0 ? method : 'GET',
-                    headers: headers,
-                    responseType: resType,
-                    transformResponse,
-                    timeout: timeout,
-                    data: data,
-                    adapter,
+                const response = yield fetch(urlWithQuery, {
+                    method,
+                    headers,
+                    body: JSON.stringify(data),
+                    signal: controller.signal,
                 });
-                return response.data;
+                if (typeof response === 'undefined') {
+                    throw new Error('Response is undefined');
+                }
+                // Handle responses with status code >= 400
+                if (response.status >= 400) {
+                    const errorData = yield response.text();
+                    throw new HttpResponseError(`Http error response: (${response.status}) ${errorData}`, response.status, response.statusText, errorData, urlWithQuery);
+                }
+                if (json) {
+                    return response.json();
+                }
+                else {
+                    return response.text();
+                }
             }
-            catch (err) {
-                if ((axios.isAxiosError(err) && err.response) || (!isNode && err.response)) {
-                    let errorData;
-                    if (typeof err.response.data === 'object') {
-                        errorData = JSON.stringify(err.response.data);
-                    }
-                    else {
-                        errorData = err.response.data;
-                    }
-                    throw new HttpResponseError(`Http error response: (${err.response.status}) ${errorData}`, err.response.status, err.response.statusText, errorData, urlWithQuery);
+            catch (e) {
+                if (e instanceof Error && e.name === 'AbortError') {
+                    throw new HttpTimeoutError(timeout, urlWithQuery);
+                }
+                else if (e instanceof HttpResponseError) {
+                    throw e;
                 }
                 else {
-                    throw new HttpRequestFailed(String(method), urlWithQuery, err);
+                    throw new HttpRequestFailed(String(method), urlWithQuery, e);
                 }
             }
+            finally {
+                clearTimeout(t);
+            }
         });
     }
 }
 
-export { HttpBackend, HttpRequestFailed, HttpResponseError, STATUS_CODE, VERSION };
+export { HttpBackend, HttpRequestFailed, HttpResponseError, HttpTimeoutError, STATUS_CODE, VERSION };
 //# sourceMappingURL=taquito-http-utils.es6.js.map

package/dist/taquito-http-utils.es6.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-http-utils.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-http-utils.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/taquito-http-utils.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('axios'), require('@taquito/core')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'axios', '@taquito/core'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoHttpUtils = {}, global.axios, global.core));
-})(this, (function (exports, axios, core) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@taquito/core')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@taquito/core'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoHttpUtils = {}, global.core));
+})(this, (function (exports, core) { 'use strict';
 
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -36,223 +36,6 @@
         return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
-    /* eslint-disable @typescript-eslint/no-var-requires */
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    const settle = require('axios/lib/core/settle');
-    const buildURL = require('axios/lib/helpers/buildURL');
-    const buildFullPath = require('axios/lib/core/buildFullPath');
-    const { isUndefined, isStandardBrowserEnv, isFormData } = require('axios/lib/utils');
-    /**
-     * - Create a request object
-     * - Get response body
-     * - Check if timeout
-     */
-    function fetchAdapter(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const request = createRequest(config);
-            const promiseChain = [getResponse(request, config)];
-            if (config.timeout && config.timeout > 0) {
-                promiseChain.push(new Promise((res) => {
-                    setTimeout(() => {
-                        const message = config.timeoutErrorMessage
-                            ? config.timeoutErrorMessage
-                            : 'timeout of ' + config.timeout + 'ms exceeded';
-                        res(createError(message, config, 'ECONNABORTED', request));
-                    }, config.timeout);
-                }));
-            }
-            const data = yield Promise.race(promiseChain);
-            return new Promise((resolve, reject) => {
-                if (data instanceof Error) {
-                    reject(data);
-                }
-                else {
-                    const c = config;
-                    'settle' in c && Object.prototype.toString.call(c.settle) === '[object Function]'
-                        ? c.settle(resolve, reject, data)
-                        : settle(resolve, reject, data);
-                }
-            });
-        });
-    }
-    /**
-     * Fetch API stage two is to get response body. This function tries to retrieve
-     * response body based on response's type
-     */
-    function getResponse(request, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const stageOne = yield fetch(request);
-                let response = {
-                    ok: stageOne.ok,
-                    status: stageOne.status,
-                    statusText: stageOne.statusText,
-                    headers: new Headers(stageOne.headers),
-                    config: config,
-                    request,
-                };
-                if (stageOne.status >= 400) {
-                    return createError('Response Error', config, 'ERR_NETWORK', request, response);
-                }
-                response = {
-                    ok: stageOne.ok,
-                    status: stageOne.status,
-                    statusText: stageOne.statusText,
-                    headers: new Headers(stageOne.headers),
-                    config: config,
-                    request,
-                };
-                if (stageOne.status >= 200 && stageOne.status !== 204) {
-                    switch (config.responseType) {
-                        case 'arraybuffer':
-                            response.data = yield stageOne.arrayBuffer();
-                            break;
-                        case 'blob':
-                            response.data = yield stageOne.blob();
-                            break;
-                        case 'json':
-                            response.data = yield stageOne.json();
-                            break;
-                        // TODO: the next option does not exist in response type
-                        // case 'formData':
-                        //     response.data = await stageOne.formData();
-                        //     break;
-                        default:
-                            response.data = yield stageOne.text();
-                            break;
-                    }
-                }
-                return response;
-            }
-            catch (e) {
-                return createError('Network Error', config, 'ERR_NETWORK', request);
-            }
-        });
-    }
-    /**
-     * This function will create a Request object based on configuration's axios
-     */
-    function createRequest(config) {
-        var _a;
-        const headers = new Headers(config.headers);
-        // HTTP basic authentication
-        if (config.auth) {
-            const username = config.auth.username || '';
-            const password = config.auth.password
-                ? decodeURI(encodeURIComponent(config.auth.password))
-                : '';
-            headers.set('Authorization', `Basic ${btoa(username + ':' + password)}`);
-        }
-        const method = (_a = config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-        const options = {
-            headers: headers,
-            method,
-        };
-        if (method !== 'GET' && method !== 'HEAD') {
-            options.body = config.data;
-            // In these cases the browser will automatically set the correct Content-Type,
-            // but only if that header hasn't been set yet. So that's why we're deleting it.
-            if (isFormData(options.body) && isStandardBrowserEnv()) {
-                headers.delete('Content-Type');
-            }
-        }
-        const c = config;
-        if ('mode' in c) {
-            options.mode = c.mode;
-        }
-        if ('cache' in c) {
-            options.cache = c.cache;
-        }
-        if ('integrity' in c) {
-            options.integrity = c.integrity;
-        }
-        if ('redirect' in c) {
-            options.redirect = c.redirect;
-        }
-        if ('referrer' in c) {
-            options.referrer = c.referrer;
-        }
-        // This config is similar to XHR’s withCredentials flag, but with three available values instead of two.
-        // So if withCredentials is not set, default value 'same-origin' will be used
-        if (!isUndefined(c.withCredentials)) {
-            options.credentials = c.withCredentials ? 'include' : 'omit';
-        }
-        const fullPath = buildFullPath(c.baseURL, c.url);
-        const url = buildURL(fullPath, c.params, c.paramsSerializer);
-        // Expected browser to throw error if there is any wrong configuration value
-        return new Request(url, options);
-    }
-    /**
-     * Note:
-     *
-     *   From version >= 0.27.0, createError function is replaced by AxiosError class.
-     *   So I copy the old createError function here for backward compatible.
-     *
-     *
-     *
-     * Create an Error with the specified message, config, error code, request and response.
-     *
-     * @param {string} message The error message.
-     * @param {Object} config The config.
-     * @param {string} [code] The error code (for example, 'ECONNABORTED').
-     * @param {Object} [request] The request.
-     * @param {Object} [response] The response.
-     * @returns {Error} The created error.
-     */
-    function createError(message, config, code, request, response) {
-        // TODO: this code never runs
-        // if ('AxiosError' in axios && axios.AxiosError && typeof axios.AxiosError === 'function' && isConstructor(axios.AxiosError)) {
-        //     return new axios.AxiosError(message, axios.AxiosError[code], config, request, response);
-        // }
-        const error = new Error(message);
-        return enhanceError(error, config, code, request, response);
-    }
-    /**
-     *
-     * Note:
-     *
-     *   This function is for backward compatible.
-     *
-     *
-     * Update an Error with the specified config, error code, and response.
-     *
-     * @param {Error} error The error to update.
-     * @param {Object} config The config.
-     * @param {string} [code] The error code (for example, 'ECONNABORTED').
-     * @param {Object} [request] The request.
-     * @param {Object} [response] The response.
-     * @returns {Error} The error.
-     */
-    function enhanceError(error, config, code, request, response) {
-        error.config = config;
-        if (code) {
-            error.code = code;
-        }
-        error.request = request;
-        error.response = response;
-        error.isAxiosError = true;
-        error.toJSON = function toJSON() {
-            return {
-                // Standard
-                message: this.message,
-                name: this.name,
-                // Microsoft
-                description: 'description' in this ? this.description : undefined,
-                number: 'number' in this ? this.number : undefined,
-                // Mozilla
-                fileName: 'fileName' in this ? this.fileName : undefined,
-                lineNumber: 'lineNumber' in this ? this.lineNumber : undefined,
-                columnNumber: 'columnNumber' in this ? this.columnNumber : undefined,
-                stack: this.stack,
-                // Axios
-                config: this.config,
-                code: this.code,
-                status: this.response && this.response.status ? this.response.status : null,
-            };
-        };
-        return error;
-    }
-
     /**
      *  @category Error
      *  @description Error that indicates a general failure in making the HTTP request
@@ -279,7 +62,20 @@
             this.statusText = statusText;
             this.body = body;
             this.url = url;
-            this.name = 'HttpResponse';
+            this.name = 'HttpResponseError';
+        }
+    }
+    /**
+     *  @category Error
+     *  @description Error
+     */
+    class HttpTimeoutError extends core.NetworkError {
+        constructor(timeout, url) {
+            super();
+            this.timeout = timeout;
+            this.url = url;
+            this.name = 'HttpTimeoutError';
+            this.message = `HTTP request timeout of ${timeout}ms exceeded`;
         }
     }
 
@@ -605,8 +401,8 @@
 
     // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
     const VERSION = {
-        "commitHash": "a908ab176a8c52c025fd43e7acd452415396f54e",
-        "version": "17.4.0"
+        "commitHash": "f6fd420c519d8d104ce768b53626f6033ecf4cd3",
+        "version": "17.5.0-beta-RC.0"
     };
 
     /**
@@ -614,13 +410,13 @@
      * @module @taquito/http-utils
      */
     var _a;
+    let fetch = globalThis === null || globalThis === void 0 ? void 0 : globalThis.fetch;
+    // Will only use browser fetch if we are in a browser environment,
+    // default to the more stable node-fetch otherwise
     const isNode = typeof process !== 'undefined' && !!((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node);
-    const adapter = isNode ? undefined : fetchAdapter;
-    var ResponseType;
-    (function (ResponseType) {
-        ResponseType["TEXT"] = "text";
-        ResponseType["JSON"] = "json";
-    })(ResponseType || (ResponseType = {}));
+    if (isNode) {
+        fetch = require('node-fetch');
+    }
     class HttpBackend {
         constructor(timeout = 30000) {
             this.timeout = timeout;
@@ -662,51 +458,55 @@
         /**
          *
          * @param options contains options to be passed for the HTTP request (url, method and timeout)
-         * @throws {@link HttpRequestFailed} | {@link HttpResponseError}
+         * @throws {@link HttpRequestFailed} | {@link HttpResponseError} | {@link HttpTimeoutError}
          */
         createRequest({ url, method, timeout = this.timeout, query, headers = {}, json = true }, data) {
             return __awaiter(this, void 0, void 0, function* () {
+                // Serializes query params
                 const urlWithQuery = url + this.serialize(query);
-                let resType;
-                let transformResponse = undefined;
+                // Adds default header entry if there aren't any Content-Type header
                 if (!headers['Content-Type']) {
                     headers['Content-Type'] = 'application/json';
                 }
-                if (!json) {
-                    resType = ResponseType.TEXT;
-                    transformResponse = [(v) => v];
-                }
-                else {
-                    resType = ResponseType.JSON;
-                }
+                // Creates a new AbortController instance to handle timeouts
+                const controller = new AbortController();
+                const t = setTimeout(() => controller.abort(), timeout);
                 try {
-                    const response = yield axios.request({
-                        url: urlWithQuery,
-                        method: method !== null && method !== void 0 ? method : 'GET',
-                        headers: headers,
-                        responseType: resType,
-                        transformResponse,
-                        timeout: timeout,
-                        data: data,
-                        adapter,
+                    const response = yield fetch(urlWithQuery, {
+                        method,
+                        headers,
+                        body: JSON.stringify(data),
+                        signal: controller.signal,
                     });
-                    return response.data;
+                    if (typeof response === 'undefined') {
+                        throw new Error('Response is undefined');
+                    }
+                    // Handle responses with status code >= 400
+                    if (response.status >= 400) {
+                        const errorData = yield response.text();
+                        throw new HttpResponseError(`Http error response: (${response.status}) ${errorData}`, response.status, response.statusText, errorData, urlWithQuery);
+                    }
+                    if (json) {
+                        return response.json();
+                    }
+                    else {
+                        return response.text();
+                    }
                 }
-                catch (err) {
-                    if ((axios.isAxiosError(err) && err.response) || (!isNode && err.response)) {
-                        let errorData;
-                        if (typeof err.response.data === 'object') {
-                            errorData = JSON.stringify(err.response.data);
-                        }
-                        else {
-                            errorData = err.response.data;
-                        }
-                        throw new HttpResponseError(`Http error response: (${err.response.status}) ${errorData}`, err.response.status, err.response.statusText, errorData, urlWithQuery);
+                catch (e) {
+                    if (e instanceof Error && e.name === 'AbortError') {
+                        throw new HttpTimeoutError(timeout, urlWithQuery);
+                    }
+                    else if (e instanceof HttpResponseError) {
+                        throw e;
                     }
                     else {
-                        throw new HttpRequestFailed(String(method), urlWithQuery, err);
+                        throw new HttpRequestFailed(String(method), urlWithQuery, e);
                     }
                 }
+                finally {
+                    clearTimeout(t);
+                }
             });
         }
     }
@@ -714,6 +514,7 @@
     exports.HttpBackend = HttpBackend;
     exports.HttpRequestFailed = HttpRequestFailed;
     exports.HttpResponseError = HttpResponseError;
+    exports.HttpTimeoutError = HttpTimeoutError;
     exports.VERSION = VERSION;
 
 }));

package/dist/taquito-http-utils.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-http-utils.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-http-utils.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/errors.d.ts

@@ -22,3 +22,12 @@ export declare class HttpResponseError extends NetworkError {
     readonly url: string;
     constructor(message: string, status: STATUS_CODE, statusText: string, body: string, url: string);
 }
+/**
+ *  @category Error
+ *  @description Error
+ */
+export declare class HttpTimeoutError extends NetworkError {
+    readonly timeout: number;
+    readonly url: string;
+    constructor(timeout: number, url: string);
+}

package/dist/types/taquito-http-utils.d.ts

@@ -4,7 +4,7 @@
  */
 export * from './status_code';
 export { VERSION } from './version';
-export { HttpRequestFailed, HttpResponseError } from './errors';
+export { HttpRequestFailed, HttpResponseError, HttpTimeoutError } from './errors';
 type ObjectType = Record<string, any>;
 export interface HttpRequestOptions {
     url: string;
@@ -24,7 +24,7 @@ export declare class HttpBackend {
     /**
      *
      * @param options contains options to be passed for the HTTP request (url, method and timeout)
-     * @throws {@link HttpRequestFailed} | {@link HttpResponseError}
+     * @throws {@link HttpRequestFailed} | {@link HttpResponseError} | {@link HttpTimeoutError}
      */
     createRequest<T>({ url, method, timeout, query, headers, json }: HttpRequestOptions, data?: object | string): Promise<T>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/http-utils",
-  "version": "17.4.0",
+  "version": "17.5.0-beta-RC.0",
   "description": "",
   "keywords": [
     "tezos"
@@ -58,13 +58,14 @@
     ]
   },
   "dependencies": {
-    "@taquito/core": "^17.4.0",
-    "axios": "^0.27.2"
+    "@taquito/core": "^17.5.0-beta-RC.0",
+    "node-fetch": "^2.7.0"
   },
   "devDependencies": {
     "@types/bluebird": "^3.5.40",
     "@types/jest": "^29.5.5",
     "@types/node": "^20",
+    "@types/node-fetch": "^2.6.9",
     "@types/superagent": "^4.1.19",
     "@typescript-eslint/eslint-plugin": "^6.8.0",
     "@typescript-eslint/parser": "^6.8.0",
@@ -89,5 +90,5 @@
     "ts-toolbelt": "^9.6.0",
     "typescript": "~5.2.2"
   },
-  "gitHead": "f7b158c2c93a38d59a113e0cf541960aa25c961d"
+  "gitHead": "d2fd61131ece885342262dfd3ef7eeb1381589ee"
 }

package/dist/lib/fetch-adapter.js

@@ -1,228 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const settle = require('axios/lib/core/settle');
-const buildURL = require('axios/lib/helpers/buildURL');
-const buildFullPath = require('axios/lib/core/buildFullPath');
-const { isUndefined, isStandardBrowserEnv, isFormData } = require('axios/lib/utils');
-/**
- * - Create a request object
- * - Get response body
- * - Check if timeout
- */
-function fetchAdapter(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const request = createRequest(config);
-        const promiseChain = [getResponse(request, config)];
-        if (config.timeout && config.timeout > 0) {
-            promiseChain.push(new Promise((res) => {
-                setTimeout(() => {
-                    const message = config.timeoutErrorMessage
-                        ? config.timeoutErrorMessage
-                        : 'timeout of ' + config.timeout + 'ms exceeded';
-                    res(createError(message, config, 'ECONNABORTED', request));
-                }, config.timeout);
-            }));
-        }
-        const data = yield Promise.race(promiseChain);
-        return new Promise((resolve, reject) => {
-            if (data instanceof Error) {
-                reject(data);
-            }
-            else {
-                const c = config;
-                'settle' in c && Object.prototype.toString.call(c.settle) === '[object Function]'
-                    ? c.settle(resolve, reject, data)
-                    : settle(resolve, reject, data);
-            }
-        });
-    });
-}
-exports.default = fetchAdapter;
-/**
- * Fetch API stage two is to get response body. This function tries to retrieve
- * response body based on response's type
- */
-function getResponse(request, config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const stageOne = yield fetch(request);
-            let response = {
-                ok: stageOne.ok,
-                status: stageOne.status,
-                statusText: stageOne.statusText,
-                headers: new Headers(stageOne.headers),
-                config: config,
-                request,
-            };
-            if (stageOne.status >= 400) {
-                return createError('Response Error', config, 'ERR_NETWORK', request, response);
-            }
-            response = {
-                ok: stageOne.ok,
-                status: stageOne.status,
-                statusText: stageOne.statusText,
-                headers: new Headers(stageOne.headers),
-                config: config,
-                request,
-            };
-            if (stageOne.status >= 200 && stageOne.status !== 204) {
-                switch (config.responseType) {
-                    case 'arraybuffer':
-                        response.data = yield stageOne.arrayBuffer();
-                        break;
-                    case 'blob':
-                        response.data = yield stageOne.blob();
-                        break;
-                    case 'json':
-                        response.data = yield stageOne.json();
-                        break;
-                    // TODO: the next option does not exist in response type
-                    // case 'formData':
-                    //     response.data = await stageOne.formData();
-                    //     break;
-                    default:
-                        response.data = yield stageOne.text();
-                        break;
-                }
-            }
-            return response;
-        }
-        catch (e) {
-            return createError('Network Error', config, 'ERR_NETWORK', request);
-        }
-    });
-}
-/**
- * This function will create a Request object based on configuration's axios
- */
-function createRequest(config) {
-    var _a;
-    const headers = new Headers(config.headers);
-    // HTTP basic authentication
-    if (config.auth) {
-        const username = config.auth.username || '';
-        const password = config.auth.password
-            ? decodeURI(encodeURIComponent(config.auth.password))
-            : '';
-        headers.set('Authorization', `Basic ${btoa(username + ':' + password)}`);
-    }
-    const method = (_a = config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-    const options = {
-        headers: headers,
-        method,
-    };
-    if (method !== 'GET' && method !== 'HEAD') {
-        options.body = config.data;
-        // In these cases the browser will automatically set the correct Content-Type,
-        // but only if that header hasn't been set yet. So that's why we're deleting it.
-        if (isFormData(options.body) && isStandardBrowserEnv()) {
-            headers.delete('Content-Type');
-        }
-    }
-    const c = config;
-    if ('mode' in c) {
-        options.mode = c.mode;
-    }
-    if ('cache' in c) {
-        options.cache = c.cache;
-    }
-    if ('integrity' in c) {
-        options.integrity = c.integrity;
-    }
-    if ('redirect' in c) {
-        options.redirect = c.redirect;
-    }
-    if ('referrer' in c) {
-        options.referrer = c.referrer;
-    }
-    // This config is similar to XHR’s withCredentials flag, but with three available values instead of two.
-    // So if withCredentials is not set, default value 'same-origin' will be used
-    if (!isUndefined(c.withCredentials)) {
-        options.credentials = c.withCredentials ? 'include' : 'omit';
-    }
-    const fullPath = buildFullPath(c.baseURL, c.url);
-    const url = buildURL(fullPath, c.params, c.paramsSerializer);
-    // Expected browser to throw error if there is any wrong configuration value
-    return new Request(url, options);
-}
-/**
- * Note:
- *
- *   From version >= 0.27.0, createError function is replaced by AxiosError class.
- *   So I copy the old createError function here for backward compatible.
- *
- *
- *
- * Create an Error with the specified message, config, error code, request and response.
- *
- * @param {string} message The error message.
- * @param {Object} config The config.
- * @param {string} [code] The error code (for example, 'ECONNABORTED').
- * @param {Object} [request] The request.
- * @param {Object} [response] The response.
- * @returns {Error} The created error.
- */
-function createError(message, config, code, request, response) {
-    // TODO: this code never runs
-    // if ('AxiosError' in axios && axios.AxiosError && typeof axios.AxiosError === 'function' && isConstructor(axios.AxiosError)) {
-    //     return new axios.AxiosError(message, axios.AxiosError[code], config, request, response);
-    // }
-    const error = new Error(message);
-    return enhanceError(error, config, code, request, response);
-}
-/**
- *
- * Note:
- *
- *   This function is for backward compatible.
- *
- *
- * Update an Error with the specified config, error code, and response.
- *
- * @param {Error} error The error to update.
- * @param {Object} config The config.
- * @param {string} [code] The error code (for example, 'ECONNABORTED').
- * @param {Object} [request] The request.
- * @param {Object} [response] The response.
- * @returns {Error} The error.
- */
-function enhanceError(error, config, code, request, response) {
-    error.config = config;
-    if (code) {
-        error.code = code;
-    }
-    error.request = request;
-    error.response = response;
-    error.isAxiosError = true;
-    error.toJSON = function toJSON() {
-        return {
-            // Standard
-            message: this.message,
-            name: this.name,
-            // Microsoft
-            description: 'description' in this ? this.description : undefined,
-            number: 'number' in this ? this.number : undefined,
-            // Mozilla
-            fileName: 'fileName' in this ? this.fileName : undefined,
-            lineNumber: 'lineNumber' in this ? this.lineNumber : undefined,
-            columnNumber: 'columnNumber' in this ? this.columnNumber : undefined,
-            stack: this.stack,
-            // Axios
-            config: this.config,
-            code: this.code,
-            status: this.response && this.response.status ? this.response.status : null,
-        };
-    };
-    return error;
-}

package/dist/types/fetch-adapter.d.ts

@@ -1,7 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-/**
- * - Create a request object
- * - Get response body
- * - Check if timeout
- */
-export default function fetchAdapter(config: AxiosRequestConfig): Promise<AxiosResponse>;