translate-maker/lib/adapters/XHR.js

Lightweight translation module. Internationalize your great project.

"use strict";

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

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

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

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

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

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

var _Adapter2 = _interopRequireDefault(require("./Adapter"));

var _File = require("./File");

function defaultGetData(_x, _x2) {
  return _defaultGetData.apply(this, arguments);
}

function _defaultGetData() {
  _defaultGetData = (0, _asyncToGenerator2.default)(
  /*#__PURE__*/
  _regenerator.default.mark(function _callee3(url, parse) {
    return _regenerator.default.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            return _context3.abrupt("return", new Promise(function (resolve, reject) {
              try {
                var XHRClass = window.XMLHttpRequest || window.ActiveXObject;
                var xhr = new XHRClass('MSXML2.XMLHTTP.3.0');

                xhr.onreadystatechange = function () {
                  if (xhr.readyState > 3) {
                    resolve(parse(xhr.responseText));
                  }
                };

                xhr.open('GET', url, true);
                xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
                xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
                xhr.send();
              } catch (e) {
                reject(e);
              }
            }));

          case 1:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3);
  }));
  return _defaultGetData.apply(this, arguments);
}

var XHR =
/*#__PURE__*/
function (_Adapter) {
  (0, _inheritsLoose2.default)(XHR, _Adapter);

  function XHR(options) {
    if (options === void 0) {
      options = {};
    }

    if (!options.path) {
      throw new Error('You need to set path');
    }

    return _Adapter.call(this, (0, _extends2.default)({
      path: undefined,
      resolvePath: _File.defaultResolvePath,
      parse: JSON.parse,
      ext: '.json',
      getData: defaultGetData,
      setData: undefined
    }, options)) || this;
  }

  var _proto = XHR.prototype;

  _proto.get =
  /*#__PURE__*/
  function () {
    var _get = (0, _asyncToGenerator2.default)(
    /*#__PURE__*/
    _regenerator.default.mark(function _callee(locale, namespace) {
      var options, resolvePath, getData, parse, path;
      return _regenerator.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              if (!(typeof namespace === 'function')) {
                _context.next = 2;
                break;
              }

              return _context.abrupt("return", this.get(locale, null, namespace));

            case 2:
              options = this.getOptions();
              resolvePath = options.resolvePath, getData = options.getData, parse = options.parse;
              path = resolvePath(locale, namespace, options);
              return _context.abrupt("return", getData(path, parse));

            case 6:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, this);
    }));

    function get(_x3, _x4) {
      return _get.apply(this, arguments);
    }

    return get;
  }();

  _proto.set =
  /*#__PURE__*/
  function () {
    var _set = (0, _asyncToGenerator2.default)(
    /*#__PURE__*/
    _regenerator.default.mark(function _callee2(locale, value, namespace) {
      return _regenerator.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              if (!(typeof namespace === 'function')) {
                _context2.next = 2;
                break;
              }

              return _context2.abrupt("return", this.set(locale, value, null, namespace));

            case 2:
              throw new Error('XHR adapter is read only');

            case 3:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2, this);
    }));

    function set(_x5, _x6, _x7) {
      return _set.apply(this, arguments);
    }

    return set;
  }();

  return XHR;
}(_Adapter2.default);

exports.default = XHR;
//# sourceMappingURL=XHR.js.map