translate-maker/lib/Translate.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 _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

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

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

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

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

var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));

var _localeId = _interopRequireDefault(require("locale-id"));

var _events = _interopRequireDefault(require("events"));

var _Tree = _interopRequireDefault(require("./Tree"));

var _filters = _interopRequireDefault(require("./filters"));

var _Memory = _interopRequireDefault(require("./adapters/Memory"));

var _Memory2 = _interopRequireDefault(require("./caches/Memory"));

var _Mode = _interopRequireDefault(require("./constants/Mode"));

var _join = _interopRequireDefault(require("./utils/join"));

function baseDefaultValue(path) {
  return "Missing default translation for: " + path;
} // TODO add || syntax


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

  function Translate(options) {
    var _this;

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

    _this = _EventEmitter.call(this) || this;

    if ((0, _isPlainObject.default)(options.adapter)) {
      throw new Error('You need to use instance of adapter or data option');
    }

    var _options = options,
        locale = _options.locale,
        namespace = _options.namespace,
        data = _options.data,
        rest = (0, _objectWithoutPropertiesLoose2.default)(_options, ["locale", "namespace", "data"]);

    if (locale || namespace) {
      throw new Error('Use method setLocale instead of option locale and namespace');
    }

    _this.options = (0, _extends3.default)({
      locales: undefined,
      // available locales
      cache: new _Memory2.default({}),
      adapter: new _Memory.default({}),
      dotNotation: true,
      mode: _Mode.default.MAIN,
      references: true,
      variables: true,
      combinations: true,
      defaultValue: baseDefaultValue
    }, rest, {
      filters: (0, _extends3.default)({}, _filters.default, rest.filters)
    });
    _this.tree = new _Tree.default((0, _assertThisInitialized2.default)(_this));

    var _this$getOptions = _this.getOptions(),
        adapter = _this$getOptions.adapter;

    if (data) {
      adapter.rehydrate(data);
    }

    return _this;
  }

  var _proto = Translate.prototype;

  _proto.hasFilter = function hasFilter(name) {
    return !!this.options.filters[name];
  };

  _proto.addFilter = function addFilter(name, filter) {
    var _extends2;

    var filters = this.options.filters;
    this.options.filters = (0, _extends3.default)({}, filters, (_extends2 = {}, _extends2[name] = filter, _extends2));
  };

  _proto.clear = function clear() {
    var _this$getOptions2 = this.getOptions(),
        cache = _this$getOptions2.cache;

    if (cache) {
      cache.clear();
    }

    this.tree = new _Tree.default(this);
  };

  _proto.waitForLocale =
  /*#__PURE__*/
  function () {
    var _waitForLocale = (0, _asyncToGenerator2.default)(
    /*#__PURE__*/
    _regenerator.default.mark(function _callee() {
      return _regenerator.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              if (this.setLocalePromise) {
                _context.next = 2;
                break;
              }

              return _context.abrupt("return", undefined);

            case 2:
              return _context.abrupt("return", this.setLocalePromise);

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

    function waitForLocale() {
      return _waitForLocale.apply(this, arguments);
    }

    return waitForLocale;
  }();

  _proto.setLocale =
  /*#__PURE__*/
  function () {
    var _setLocale = (0, _asyncToGenerator2.default)(
    /*#__PURE__*/
    _regenerator.default.mark(function _callee3(locale, namespace) {
      var _this2 = this;

      var currentPromise;
      return _regenerator.default.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              currentPromise = this.setLocalePromise;
              this.setLocalePromise = new Promise(
              /*#__PURE__*/
              function () {
                var _ref = (0, _asyncToGenerator2.default)(
                /*#__PURE__*/
                _regenerator.default.mark(function _callee2(resolve, reject) {
                  var options, adapter;
                  return _regenerator.default.wrap(function _callee2$(_context2) {
                    while (1) {
                      switch (_context2.prev = _context2.next) {
                        case 0:
                          _context2.prev = 0;
                          _context2.next = 3;
                          return currentPromise;

                        case 3:
                          _context2.next = 9;
                          break;

                        case 5:
                          _context2.prev = 5;
                          _context2.t0 = _context2["catch"](0);
                          reject(_context2.t0);
                          return _context2.abrupt("return");

                        case 9:
                          if (locale) {
                            _context2.next = 11;
                            break;
                          }

                          throw new Error('Locale is undefined');

                        case 11:
                          options = _this2.getOptions();

                          if (!(options.locales && options.locales.indexOf(locale) === -1)) {
                            _context2.next = 14;
                            break;
                          }

                          throw new Error('Locale is not allowed. Setup locales');

                        case 14:
                          adapter = _this2.getAdapter();
                          adapter.get(locale, namespace).then(function (data) {
                            var sameLocale = options.locale === locale;

                            if (!sameLocale) {
                              _this2.clear();

                              _this2.options = (0, _extends3.default)({}, options, {
                                locale: locale
                              });
                            }

                            if (namespace) {
                              _this2.set(namespace, data);
                            } else {
                              _this2.set(data);
                            }

                            if (!sameLocale) {
                              _this2.emit('locale', locale, namespace);
                            }

                            resolve(data);
                          }, reject);

                        case 16:
                        case "end":
                          return _context2.stop();
                      }
                    }
                  }, _callee2, null, [[0, 5]]);
                }));

                return function (_x3, _x4) {
                  return _ref.apply(this, arguments);
                };
              }());
              return _context3.abrupt("return", this.setLocalePromise);

            case 3:
            case "end":
              return _context3.stop();
          }
        }
      }, _callee3, this);
    }));

    function setLocale(_x, _x2) {
      return _setLocale.apply(this, arguments);
    }

    return setLocale;
  }();

  _proto.loadNamespace =
  /*#__PURE__*/
  function () {
    var _loadNamespace = (0, _asyncToGenerator2.default)(
    /*#__PURE__*/
    _regenerator.default.mark(function _callee4(namespace) {
      var options;
      return _regenerator.default.wrap(function _callee4$(_context4) {
        while (1) {
          switch (_context4.prev = _context4.next) {
            case 0:
              _context4.next = 2;
              return this.setLocalePromise;

            case 2:
              options = this.getOptions();
              return _context4.abrupt("return", this.setLocale(options.locale, namespace));

            case 4:
            case "end":
              return _context4.stop();
          }
        }
      }, _callee4, this);
    }));

    function loadNamespace(_x5) {
      return _loadNamespace.apply(this, arguments);
    }

    return loadNamespace;
  }();

  _proto.get = function get(path, attrs, defaultValue, pure) {
    var _this3 = this;

    if (path === undefined || path === null) {
      return undefined;
    }

    if ((0, _isPlainObject.default)(path)) {
      var translated = {};
      Object.keys(path).forEach(function (key) {
        translated[key] = _this3.get(path[key], attrs, defaultValue);
      });
      return translated;
    }

    var items = this.tree.get(path, attrs, defaultValue);
    return pure ? items : (0, _join.default)(items);
  };

  _proto.set = function set(path, value) {
    var result = this.tree.set(path, value);
    this.emit('changed');
    return result;
  };

  _proto.getOptions = function getOptions() {
    return this.options;
  };

  _proto.getLocale = function getLocale() {
    return this.getOptions().locale;
  };

  _proto.getLanguage = function getLanguage() {
    var locale = this.getLocale();

    if (locale) {
      var l = (0, _localeId.default)(locale);
      return l && l.language;
    }

    return locale;
  };

  _proto.getCache = function getCache() {
    return this.getOptions().cache;
  };

  _proto.getAdapter = function getAdapter() {
    return this.getOptions().adapter;
  };

  _proto.setFilter = function setFilter(type, fn) {
    var _this4 = this;

    if ((0, _isPlainObject.default)(type)) {
      Object.keys(type).forEach(function (filterType) {
        return _this4.setFilter(filterType, type[filterType]);
      });
      return;
    }

    this.getOptions().filters[type] = fn;
  };

  _proto.getFilter = function getFilter(type) {
    var _this$getOptions3 = this.getOptions(),
        filters = _this$getOptions3.filters;

    return filters && filters[type];
  };

  return Translate;
}(_events.default);

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