ptokens-providers/dist/ptokens-providers.cjs.js

repo holding the code related to network providers

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var _toConsumableArray = _interopDefault(require('@babel/runtime/helpers/toConsumableArray'));
var _asyncToGenerator = _interopDefault(require('@babel/runtime/helpers/asyncToGenerator'));
var _classCallCheck = _interopDefault(require('@babel/runtime/helpers/classCallCheck'));
var _createClass = _interopDefault(require('@babel/runtime/helpers/createClass'));
var _regeneratorRuntime = _interopDefault(require('@babel/runtime/regenerator'));
var axios = _interopDefault(require('axios'));

var DEFAULT_TIMEOUT = 10000;
var DEFAULT_HEADERS = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
  'Access-Control-Allow-Headers': 'Origin, Content-Type',
  'Content-Type': 'application/json'
};
var HttpProvider = function () {
  function HttpProvider(_endpoint, _headers) {
    _classCallCheck(this, HttpProvider);
    this.headers = _headers || DEFAULT_HEADERS;
    this.endpoint = _endpoint || null;
    this.api = _endpoint ? axios.create({
      baseURL: _endpoint,
      headers: _headers || DEFAULT_HEADERS
    }) : null;
  }
  _createClass(HttpProvider, [{
    key: "call",
    value: function () {
      var _call = _asyncToGenerator( _regeneratorRuntime.mark(function _callee(_callType, _apiPath) {
        var _params,
            _timeout,
            _this$api,
            CancelToken,
            options,
            details,
            _yield$this$api$_call,
            data,
            _args = arguments;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _params = _args.length > 2 && _args[2] !== undefined ? _args[2] : [];
                _timeout = _args.length > 3 && _args[3] !== undefined ? _args[3] : DEFAULT_TIMEOUT;
                _context.prev = 2;
                CancelToken = axios.CancelToken;
                options = {
                  cancelToken: _timeout ? new CancelToken(function (_cancel) {
                    return setTimeout(function () {
                      return _cancel("timeout of ".concat(_timeout, "ms exceeded"));
                    }, _timeout);
                  }) : undefined
                };
                details = [_apiPath].concat(_toConsumableArray(_callType === 'GET' ? [options] : [_params, options]));
                _context.next = 8;
                return (_this$api = this.api)[_callType.toLowerCase()].apply(_this$api, _toConsumableArray(details));
              case 8:
                _yield$this$api$_call = _context.sent;
                data = _yield$this$api$_call.data;
                return _context.abrupt("return", data);
              case 13:
                _context.prev = 13;
                _context.t0 = _context["catch"](2);
                throw new Error(_context.t0.message);
              case 16:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[2, 13]]);
      }));
      function call(_x, _x2) {
        return _call.apply(this, arguments);
      }
      return call;
    }()
  }, {
    key: "setEndpoint",
    value: function setEndpoint(_endpoint) {
      this.endpoint = _endpoint;
      this.api = axios.create({
        baseURL: _endpoint,
        headers: this.headers
      });
    }
  }, {
    key: "setHeaders",
    value: function setHeaders(_headers) {
      this.headers = _headers;
      this.api = axios.create({
        baseURL: this.endpoint,
        headers: _headers
      });
    }
  }]);
  return HttpProvider;
}();

exports.HttpProvider = HttpProvider;