@fmal/http-service/dist/cjs/index.js

A HTTP service - orignally @cerebral/http

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

exports.__esModule = true;
exports.default = HttpServiceFactory;
exports.HttpServiceError = void 0;

var _request = _interopRequireDefault(require("./request"));

var _utils = require("./utils");

var _fileUpload = _interopRequireDefault(require("./fileUpload"));

var _DEFAULT_OPTIONS = _interopRequireDefault(require("./DEFAULT_OPTIONS"));

var _HttpServiceError = _interopRequireDefault(require("./HttpServiceError"));

exports.HttpServiceError = _HttpServiceError.default;

function HttpServiceFactory(passedOptions) {
  var moduleOptions = (0, _utils.mergeWith)({}, _DEFAULT_OPTIONS.default);

  if (typeof passedOptions === 'function') {
    moduleOptions = passedOptions(moduleOptions);
  } else if (passedOptions) {
    moduleOptions = (0, _utils.mergeWith)(passedOptions, _DEFAULT_OPTIONS.default);
  }

  var requests = {};

  function createAbortablePromise(url, cb) {
    return new Promise(function (resolve, reject) {
      requests[url] = {
        resolve: resolve,
        reject: reject,
        // eslint-disable-next-line standard/no-callback-literal
        xhr: cb(function (payload) {
          delete requests[url];
          resolve(payload);
        }, function (error) {
          delete requests[url];
          reject(error);
        })
      };
    });
  }

  function requestService(options) {
    options = (0, _utils.mergeWith)(options, moduleOptions);

    if (options.onProgress) {
      options.onProgress = this.context.resolve.value(options.onProgress);
    }

    options.method = options.method.toUpperCase();
    return createAbortablePromise(options.url, function (resolve, reject) {
      return (0, _request.default)(options, (0, _utils.createResponse)(options, resolve, reject));
    });
  }

  return {
    request: requestService,
    get: function get(url, passedQuery, options) {
      if (options === void 0) {
        options = {};
      }

      var query = passedQuery || options.query;
      options.url = query && Object.keys(query).length ? url + '?' + (0, _utils.urlEncode)(query) : url;
      options.method = 'GET';
      return requestService.call(this, options);
    },
    post: function post(url, body, options) {
      if (options === void 0) {
        options = {};
      }

      options.url = options.query && Object.keys(options.query).length ? url + '?' + (0, _utils.urlEncode)(options.query) : url;
      options.method = 'POST';
      options.body = body;
      return requestService.call(this, options);
    },
    put: function put(url, body, options) {
      if (options === void 0) {
        options = {};
      }

      options.url = options.query && Object.keys(options.query).length ? url + '?' + (0, _utils.urlEncode)(options.query) : url;
      options.method = 'PUT';
      options.body = body;
      return requestService.call(this, options);
    },
    patch: function patch(url, body, options) {
      if (options === void 0) {
        options = {};
      }

      options.url = options.query && Object.keys(options.query).length ? url + '?' + (0, _utils.urlEncode)(options.query) : url;
      options.method = 'PATCH';
      options.body = body;
      return requestService.call(this, options);
    },
    delete: function _delete(url, query, options) {
      if (options === void 0) {
        options = {};
      }

      options.url = options.query && Object.keys(options.query).length ? url + '?' + (0, _utils.urlEncode)(options.query) : url;
      options.method = 'DELETE';
      return requestService.call(this, options);
    },
    updateOptions: function updateOptions(newOptions) {
      moduleOptions = (0, _utils.mergeWith)(newOptions, moduleOptions);
    },
    abort: function abort(regexp) {
      var matchingUrls = Object.keys(requests).filter(function (url) {
        return Boolean(url.match(new RegExp(regexp)));
      });
      matchingUrls.forEach(function (url) {
        requests[url].xhr.abort();
      });
    },
    uploadFile: function uploadFile(url, files, options) {
      if (options === void 0) {
        options = {};
      }

      options.url = moduleOptions.baseUrl + url;
      options.onProgress = typeof options.onProgress === 'string' ? this.context.controller.getSequence(options.onProgress) : options.onProgress;
      return new _fileUpload.default(options).send(files);
    }
  };
}