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

A HTTP service - orignally @cerebral/http

"use strict";

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

exports.__esModule = true;
exports.createResponse = createResponse;
exports.mergeWith = mergeWith;
exports.urlEncode = urlEncode;
exports.parseHeaders = parseHeaders;
exports.processResponse = processResponse;
exports.getAllResponseHeaders = getAllResponseHeaders;

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

function createResponse(options, resolve, reject) {
  return function (event) {
    switch (event.type) {
      case 'load':
        return options.onResponse(event.currentTarget, resolve, reject, options);

      case 'progress':
        if (options.onProgress && event.lengthComputable) {
          options.onProgress({
            progress: Number(event.loaded / event.total * 100).toFixed()
          });
        }

        break;

      case 'error':
        reject(new _HttpServiceError.default(undefined, event.currentTarget.status, getAllResponseHeaders(event.currentTarget), event.currentTarget.responseText, event.currentTarget.responseText || 'request error'));
        break;

      case 'abort':
        reject(new _HttpServiceError.default(event.type, event.currentTarget.status, getAllResponseHeaders(event.currentTarget), null, 'request abort', true));
        break;

      case 'timeout':
        reject(new _HttpServiceError.default(event.type, event.currentTarget.status, getAllResponseHeaders(event.currentTarget), null, 'request timeout'));
        break;
    }
  };
}

function mergeWith(optionsA, optionsB) {
  return Object.keys(optionsB).reduce(function (newOptions, key) {
    if (!newOptions[key]) {
      newOptions[key] = optionsB[key];
    } else if (key === 'headers') {
      newOptions[key] = mergeWith(newOptions[key], optionsB[key] || {});
    }

    return newOptions;
  }, optionsA);
}

function urlEncode(obj, prefix) {
  var str = [];

  for (var p in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, p)) {
      var k = prefix ? prefix + '[' + p + ']' : p;
      var v = obj[p];
      str.push(typeof v === 'object' ? urlEncode(v, k) : encodeURIComponent(k) + '=' + encodeURIComponent(v));
    }
  }

  return str.join('&');
}

function parseHeaders(rawHeaders) {
  if (!rawHeaders) {
    return null;
  }

  var headerPairs = rawHeaders.replace(/\r?\n$/, '').split(/\r?\n/);
  return headerPairs.reduce(function (parsedHeaders, headerPair) {
    var index = headerPair.indexOf(':');
    var key = headerPair.substr(0, index).trim().toLowerCase();
    var value = headerPair.substr(index + 1).trim();

    if (key) {
      parsedHeaders[key] = parsedHeaders[key] ? parsedHeaders[key] + ', ' + value : value;
    }

    return parsedHeaders;
  }, {});
}

function processResponse(httpAction, path) {
  return httpAction.then(function (response) {
    if (path && path[response.status]) {
      return path[response.status]({
        response: response
      });
    }

    return path && path.success ? path.success({
      response: response
    }) : {
      response: response
    };
  }) // This error will be an instance of HttpError
  .catch(function (error) {
    if (!path) {
      throw error;
    }

    if (error.type === 'abort' && path.abort) {
      return path.abort({
        error: error.toJSON()
      });
    }

    if (error.type === 'timeout' && path.timeout) {
      return path.timeout({
        error: error.toJSON()
      });
    }

    if (path[error.response.status]) {
      return path[error.response.status]({
        error: error.toJSON()
      });
    }

    if (path.error) {
      return path.error({
        error: error.toJSON()
      });
    }

    throw error;
  });
}

function getAllResponseHeaders(xhr) {
  return 'getAllResponseHeaders' in xhr ? parseHeaders(xhr.getAllResponseHeaders()) : null;
}