function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
import { defaults, makePromise } from './utils.js';
|
import request from './request.js';
|
|
var getDefaults = function getDefaults() {
|
return {
|
loadPath: '/locales/{{lng}}/{{ns}}.json',
|
addPath: '/locales/add/{{lng}}/{{ns}}',
|
allowMultiLoading: false,
|
parse: function parse(data) {
|
return JSON.parse(data);
|
},
|
stringify: JSON.stringify,
|
parsePayload: function parsePayload(namespace, key, fallbackValue) {
|
return _defineProperty({}, key, fallbackValue || '');
|
},
|
request: request,
|
reloadInterval: typeof window !== 'undefined' ? false : 60 * 60 * 1000,
|
customHeaders: {},
|
queryStringParams: {},
|
crossDomain: false,
|
withCredentials: false,
|
overrideMimeType: false,
|
requestOptions: {
|
mode: 'cors',
|
credentials: 'same-origin',
|
cache: 'default'
|
}
|
};
|
};
|
|
var Backend = function () {
|
function Backend(services) {
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
var allOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
_classCallCheck(this, Backend);
|
|
this.services = services;
|
this.options = options;
|
this.allOptions = allOptions;
|
this.type = 'backend';
|
this.init(services, options, allOptions);
|
}
|
|
_createClass(Backend, [{
|
key: "init",
|
value: function init(services) {
|
var _this = this;
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
var allOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
this.services = services;
|
this.options = defaults(options, this.options || {}, getDefaults());
|
this.allOptions = allOptions;
|
|
if (this.services && this.options.reloadInterval) {
|
setInterval(function () {
|
return _this.reload();
|
}, this.options.reloadInterval);
|
}
|
}
|
}, {
|
key: "readMulti",
|
value: function readMulti(languages, namespaces, callback) {
|
this._readAny(languages, languages, namespaces, namespaces, callback);
|
}
|
}, {
|
key: "read",
|
value: function read(language, namespace, callback) {
|
this._readAny([language], language, [namespace], namespace, callback);
|
}
|
}, {
|
key: "_readAny",
|
value: function _readAny(languages, loadUrlLanguages, namespaces, loadUrlNamespaces, callback) {
|
var _this2 = this;
|
|
var loadPath = this.options.loadPath;
|
|
if (typeof this.options.loadPath === 'function') {
|
loadPath = this.options.loadPath(languages, namespaces);
|
}
|
|
loadPath = makePromise(loadPath);
|
loadPath.then(function (resolvedLoadPath) {
|
if (!resolvedLoadPath) return callback(null, {});
|
|
var url = _this2.services.interpolator.interpolate(resolvedLoadPath, {
|
lng: languages.join('+'),
|
ns: namespaces.join('+')
|
});
|
|
_this2.loadUrl(url, callback, loadUrlLanguages, loadUrlNamespaces);
|
});
|
}
|
}, {
|
key: "loadUrl",
|
value: function loadUrl(url, callback, languages, namespaces) {
|
var _this3 = this;
|
|
this.options.request(this.options, url, undefined, function (err, res) {
|
if (res && (res.status >= 500 && res.status < 600 || !res.status)) return callback('failed loading ' + url + '; status code: ' + res.status, true);
|
if (res && res.status >= 400 && res.status < 500) return callback('failed loading ' + url + '; status code: ' + res.status, false);
|
if (!res && err && err.message && err.message.indexOf('Failed to fetch') > -1) return callback('failed loading ' + url + ': ' + err.message, true);
|
if (err) return callback(err, false);
|
var ret, parseErr;
|
|
try {
|
if (typeof res.data === 'string') {
|
ret = _this3.options.parse(res.data, languages, namespaces);
|
} else {
|
ret = res.data;
|
}
|
} catch (e) {
|
parseErr = 'failed parsing ' + url + ' to json';
|
}
|
|
if (parseErr) return callback(parseErr, false);
|
callback(null, ret);
|
});
|
}
|
}, {
|
key: "create",
|
value: function create(languages, namespace, key, fallbackValue, callback) {
|
var _this4 = this;
|
|
if (!this.options.addPath) return;
|
if (typeof languages === 'string') languages = [languages];
|
var payload = this.options.parsePayload(namespace, key, fallbackValue);
|
var finished = 0;
|
var dataArray = [];
|
var resArray = [];
|
languages.forEach(function (lng) {
|
var addPath = _this4.options.addPath;
|
|
if (typeof _this4.options.addPath === 'function') {
|
addPath = _this4.options.addPath(lng, namespace);
|
}
|
|
var url = _this4.services.interpolator.interpolate(addPath, {
|
lng: lng,
|
ns: namespace
|
});
|
|
_this4.options.request(_this4.options, url, payload, function (data, res) {
|
finished += 1;
|
dataArray.push(data);
|
resArray.push(res);
|
|
if (finished === languages.length) {
|
if (callback) callback(dataArray, resArray);
|
}
|
});
|
});
|
}
|
}, {
|
key: "reload",
|
value: function reload() {
|
var _this5 = this;
|
|
var _this$services = this.services,
|
backendConnector = _this$services.backendConnector,
|
languageUtils = _this$services.languageUtils,
|
logger = _this$services.logger;
|
var currentLanguage = backendConnector.language;
|
if (currentLanguage && currentLanguage.toLowerCase() === 'cimode') return;
|
var toLoad = [];
|
|
var append = function append(lng) {
|
var lngs = languageUtils.toResolveHierarchy(lng);
|
lngs.forEach(function (l) {
|
if (toLoad.indexOf(l) < 0) toLoad.push(l);
|
});
|
};
|
|
append(currentLanguage);
|
if (this.allOptions.preload) this.allOptions.preload.forEach(function (l) {
|
return append(l);
|
});
|
toLoad.forEach(function (lng) {
|
_this5.allOptions.ns.forEach(function (ns) {
|
backendConnector.read(lng, ns, 'read', null, null, function (err, data) {
|
if (err) logger.warn("loading namespace ".concat(ns, " for language ").concat(lng, " failed"), err);
|
if (!err && data) logger.log("loaded namespace ".concat(ns, " for language ").concat(lng), data);
|
backendConnector.loaded("".concat(lng, "|").concat(ns), err, data);
|
});
|
});
|
});
|
}
|
}]);
|
|
return Backend;
|
}();
|
|
Backend.type = 'backend';
|
export default Backend;
|
