tui-code-snippet/ajax/index.js

TOAST UI Utility: CodeSnippet

"use strict";

exports.__esModule = true;
exports["default"] = void 0;

var _forEachArray = _interopRequireDefault(require("../collection/forEachArray"));

var _forEachOwnProperties = _interopRequireDefault(require("../collection/forEachOwnProperties"));

var _extend = _interopRequireDefault(require("../object/extend"));

var _isArray = _interopRequireDefault(require("../type/isArray"));

var _isEmpty = _interopRequireDefault(require("../type/isEmpty"));

var _isFunction = _interopRequireDefault(require("../type/isFunction"));

var _isNull = _interopRequireDefault(require("../type/isNull"));

var _isObject = _interopRequireDefault(require("../type/isObject"));

var _isUndefined = _interopRequireDefault(require("../type/isUndefined"));

function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    "default": obj
  };
}

function encodePairs(key, value) {
  return encodeURIComponent(key) + "=" + encodeURIComponent((0, _isNull["default"])(value) || (0, _isUndefined["default"])(value) ? '' : value);
}

function serializeParams(key, value, serializedList) {
  if ((0, _isArray["default"])(value)) {
    (0, _forEachArray["default"])(value, function (arrVal, index) {
      serializeParams(key + "[" + ((0, _isObject["default"])(arrVal) ? index : '') + "]", arrVal, serializedList);
    });
  } else if ((0, _isObject["default"])(value)) {
    (0, _forEachOwnProperties["default"])(value, function (objValue, objKey) {
      serializeParams(key + "[" + objKey + "]", objValue, serializedList);
    });
  } else {
    serializedList.push(encodePairs(key, value));
  }
}

function serialize(params) {
  if (!params || (0, _isEmpty["default"])(params)) {
    return '';
  }

  var serializedList = [];
  (0, _forEachOwnProperties["default"])(params, function (value, key) {
    serializeParams(key, value, serializedList);
  });
  return serializedList.join('&');
}

var getDefaultOptions = function getDefaultOptions() {
  return {
    baseURL: '',
    headers: {
      common: {},
      get: {},
      post: {},
      put: {},
      "delete": {},
      patch: {},
      options: {},
      head: {}
    },
    serializer: serialize
  };
};

var HTTP_PROTOCOL_REGEXP = /^(http|https):\/\//i;

function combineURL(baseURL, url) {
  if (HTTP_PROTOCOL_REGEXP.test(url)) {
    return url;
  }

  if (baseURL.slice(-1) === '/' && url.slice(0, 1) === '/') {
    url = url.slice(1);
  }

  return baseURL + url;
}

function getComputedOptions(defaultOptions, customOptions) {
  var baseURL = defaultOptions.baseURL,
      defaultHeaders = defaultOptions.headers,
      defaultSerializer = defaultOptions.serializer,
      defaultBeforeRequest = defaultOptions.beforeRequest,
      defaultSuccess = defaultOptions.success,
      defaultError = defaultOptions.error,
      defaultComplete = defaultOptions.complete;
  var url = customOptions.url,
      contentType = customOptions.contentType,
      method = customOptions.method,
      params = customOptions.params,
      headers = customOptions.headers,
      serializer = customOptions.serializer,
      beforeRequest = customOptions.beforeRequest,
      success = customOptions.success,
      error = customOptions.error,
      complete = customOptions.complete,
      withCredentials = customOptions.withCredentials,
      mimeType = customOptions.mimeType;
  var options = {
    url: combineURL(baseURL, url),
    method: method,
    params: params,
    headers: (0, _extend["default"])(defaultHeaders.common, defaultHeaders[method.toLowerCase()], headers),
    serializer: serializer || defaultSerializer || serialize,
    beforeRequest: [defaultBeforeRequest, beforeRequest],
    success: [defaultSuccess, success],
    error: [defaultError, error],
    complete: [defaultComplete, complete],
    withCredentials: withCredentials,
    mimeType: mimeType
  };
  options.contentType = contentType || options.headers['Content-Type'];
  delete options.headers['Content-Type'];
  return options;
}

function validateStatus(status) {
  return status >= 200 && status < 300;
}

function hasRequestBody(method) {
  return /^(?:POST|PUT|PATCH)$/.test(method.toUpperCase());
}

function executeCallback(callback, param) {
  if ((0, _isArray["default"])(callback)) {
    (0, _forEachArray["default"])(callback, function (fn) {
      return executeCallback(fn, param);
    });
  } else if ((0, _isFunction["default"])(callback)) {
    callback(param);
  }
}

function parseHeaders(text) {
  var headers = {};
  (0, _forEachArray["default"])(text.split('\r\n'), function (header) {
    var _header$split = header.split(': '),
        key = _header$split[0],
        value = _header$split[1];

    if (key !== '' && !(0, _isUndefined["default"])(value)) {
      headers[key] = value;
    }
  });
  return headers;
}

function parseJSONData(data) {
  var result = '';

  try {
    result = JSON.parse(data);
  } catch (_) {
    result = data;
  }

  return result;
}

var REQUEST_DONE = 4;

function handleReadyStateChange(xhr, options) {
  var readyState = xhr.readyState;

  if (readyState != REQUEST_DONE) {
    return;
  }

  var status = xhr.status,
      statusText = xhr.statusText,
      responseText = xhr.responseText;
  var success = options.success,
      resolve = options.resolve,
      error = options.error,
      reject = options.reject,
      complete = options.complete;

  if (validateStatus(status)) {
    var contentType = xhr.getResponseHeader('Content-Type');
    var data = responseText;

    if (contentType && contentType.indexOf('application/json') > -1) {
      data = parseJSONData(data);
    }

    executeCallback([success, resolve], {
      status: status,
      statusText: statusText,
      data: data,
      headers: parseHeaders(xhr.getAllResponseHeaders())
    });
  } else {
    executeCallback([error, reject], {
      status: status,
      statusText: statusText
    });
  }

  executeCallback(complete, {
    status: status,
    statusText: statusText
  });
}

var QS_DELIM_REGEXP = /\?/;

function open(xhr, options) {
  var url = options.url,
      method = options.method,
      serializer = options.serializer,
      params = options.params;
  var requestUrl = url;

  if (!hasRequestBody(method) && params) {
    var qs = (QS_DELIM_REGEXP.test(url) ? '&' : '?') + serializer(params);
    requestUrl = "" + url + qs;
  }

  xhr.open(method, requestUrl);
}

function applyConfig(xhr, options) {
  var method = options.method,
      contentType = options.contentType,
      mimeType = options.mimeType,
      headers = options.headers,
      _options$withCredenti = options.withCredentials,
      withCredentials = _options$withCredenti === void 0 ? false : _options$withCredenti;

  if (withCredentials) {
    xhr.withCredentials = withCredentials;
  }

  if (mimeType) {
    xhr.overrideMimeType(mimeType);
  }

  (0, _forEachOwnProperties["default"])(headers, function (value, header) {
    if (!(0, _isObject["default"])(value)) {
      xhr.setRequestHeader(header, value);
    }
  });

  if (hasRequestBody(method)) {
    xhr.setRequestHeader('Content-Type', contentType + "; charset=UTF-8");
  }

  xhr.setRequestHeader('x-requested-with', 'XMLHttpRequest');
}

var ENCODED_SPACE_REGEXP = /%20/g;

function send(xhr, options) {
  var method = options.method,
      serializer = options.serializer,
      beforeRequest = options.beforeRequest,
      _options$params = options.params,
      params = _options$params === void 0 ? {} : _options$params,
      _options$contentType = options.contentType,
      contentType = _options$contentType === void 0 ? 'application/x-www-form-urlencoded' : _options$contentType;
  var body = null;

  if (hasRequestBody(method)) {
    body = contentType.indexOf('application/x-www-form-urlencoded') > -1 ? serializer(params).replace(ENCODED_SPACE_REGEXP, '+') : JSON.stringify(params);
  }

  xhr.onreadystatechange = function () {
    return handleReadyStateChange(xhr, options);
  };

  executeCallback(beforeRequest, xhr);
  xhr.send(body);
}

function ajax(options) {
  var xhr = new XMLHttpRequest();

  var request = function request(opts) {
    return (0, _forEachArray["default"])([open, applyConfig, send], function (fn) {
      return fn(xhr, opts);
    });
  };

  options = getComputedOptions(ajax.defaults, options);

  if (typeof Promise !== 'undefined') {
    return new Promise(function (resolve, reject) {
      request((0, _extend["default"])(options, {
        resolve: resolve,
        reject: reject
      }));
    });
  }

  request(options);
  return null;
}

ajax.defaults = getDefaultOptions();

ajax._reset = function () {
  ajax.defaults = getDefaultOptions();
};

ajax._request = function (url, method, options) {
  if (options === void 0) {
    options = {};
  }

  return ajax((0, _extend["default"])(options, {
    url: url,
    method: method
  }));
};

(0, _forEachArray["default"])(['get', 'post', 'put', 'delete', 'patch', 'options', 'head'], function (type) {
  ajax[type] = function (url, options) {
    return ajax._request(url, type.toUpperCase(), options);
  };
});
var _default = ajax;
exports["default"] = _default;
module.exports = exports["default"];