'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopNamespace(e) {
  if (e && e.__esModule) { return e; } else {
    var n = {};
    if (e) {
      Object.keys(e).forEach(function (k) {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () {
            return e[k];
          }
        });
      });
    }
    n['default'] = e;
    return n;
  }
}

var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
var utils = require('./utils.js');

/**
 * Dynamic import of a translation file, typically a JSON file
 * You have to define an alias (`resolve.alias`) in your webpack configuration
 * i.e.
 * {
 *   resolve: {
 *     alias: {
 *       i18n: path.resolve('./i18n')
 *     }
 *   },
 *   //...
 * },
 * @param {String} locale a locale, i.e. `en`
 * @returns {Object} imported module, default export in `default` field
 */

function importMessages(_x) {
  return _importMessages.apply(this, arguments);
}
/**
 * Dynamic import of `react-intl`'s locale data
 *
 * @see https://github.com/yahoo/react-intl/wiki#locale-data-in-browsers
 * @param {String} locale a locale, i.e. `en`
 * @returns {import('react-intl').LocaleData} locale data object
 */

function _importMessages() {
  _importMessages = _rollupPluginBabelHelpers.asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(locale) {
    var normalizedLocale, importedModule;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.prev = 0;
            normalizedLocale = utils.normalizeLocale(locale);
            _context.next = 4;
            return Promise.resolve().then(function () { return _interopNamespace(require("i18n/".concat(normalizedLocale))); });

          case 4:
            importedModule = _context.sent;
            return _context.abrupt("return", importedModule.default);

          case 8:
            _context.prev = 8;
            _context.t0 = _context["catch"](0);
            return _context.abrupt("return", {});

          case 11:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[0, 8]]);
  }));
  return _importMessages.apply(this, arguments);
}

function importLocaleData(_x2) {
  return _importLocaleData.apply(this, arguments);
}
/**
 * Dynamic import of the `Intl` polyfill, but only if there is no support
 */

function _importLocaleData() {
  _importLocaleData = _rollupPluginBabelHelpers.asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(locale) {
    var normalizedLocale, _normalizedLocale$spl, _normalizedLocale$spl2, language, importedModule, _importedModule$defau, _importedModule$defau2, specificLocaleData, defaultLocaleData;

    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            normalizedLocale = utils.normalizeLocale(locale);
            _normalizedLocale$spl = normalizedLocale.split('-'), _normalizedLocale$spl2 = _rollupPluginBabelHelpers.slicedToArray(_normalizedLocale$spl, 1), language = _normalizedLocale$spl2[0];
            _context2.next = 4;
            return Promise.resolve().then(function () { return _interopNamespace(require("react-intl/locale-data/".concat(language))); });

          case 4:
            importedModule = _context2.sent;
            // react-intl's locale data provides additional specific locales, i.e. `en-GB`: we'll pick the base locale data
            _importedModule$defau = importedModule.default.filter(function (localeData) {
              return localeData.locale === normalizedLocale;
            }), _importedModule$defau2 = _rollupPluginBabelHelpers.slicedToArray(_importedModule$defau, 1), specificLocaleData = _importedModule$defau2[0];
            defaultLocaleData = importedModule.default.filter(function (localeData) {
              return localeData.locale === language;
            });
            return _context2.abrupt("return", specificLocaleData || defaultLocaleData);

          case 8:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));
  return _importLocaleData.apply(this, arguments);
}

function importIntl() {
  return _importIntl.apply(this, arguments);
}

function _importIntl() {
  _importIntl = _rollupPluginBabelHelpers.asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3() {
    return regeneratorRuntime.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            if (global.Intl) {
              _context3.next = 3;
              break;
            }

            _context3.next = 3;
            return Promise.resolve().then(function () { return require('../node_modules/intl/index.js'); });

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

exports.importIntl = importIntl;
exports.importLocaleData = importLocaleData;
exports.importMessages = importMessages;
//# sourceMappingURL=import.js.map