387 lines
12 KiB
JavaScript
387 lines
12 KiB
JavaScript
// Module ID: 1270
|
|
// Function ID: 14334
|
|
// Name: MessageLoader
|
|
// Dependencies: []
|
|
// Exports: createLoader, loadAllMessagesInLocale, waitForAllDefaultIntlMessagesLoaded
|
|
|
|
// Module 1270 (MessageLoader)
|
|
let closure_3 = require(dependencyMap[0]);
|
|
let closure_4 = require(dependencyMap[1]);
|
|
let closure_5 = require(dependencyMap[2]);
|
|
let fn = this;
|
|
if (this) {
|
|
fn = this.__awaiter;
|
|
}
|
|
if (!fn) {
|
|
fn = (arg0, arg1, arg2, arg3) => {
|
|
let _Promise = arg2;
|
|
const require = arg0;
|
|
const module = arg1;
|
|
let dependencyMap = arg2;
|
|
let closure_3 = arg3;
|
|
if (!arg2) {
|
|
dependencyMap = Promise;
|
|
_Promise = Promise;
|
|
}
|
|
_Promise = new _Promise((arg0, arg1) => {
|
|
function fulfilled(arg0) {
|
|
step(iter.next(arg0));
|
|
}
|
|
let arg3 = function rejected(arg0) {
|
|
step(iter.throw(arg0));
|
|
};
|
|
function step(iter) {
|
|
if (iter.done) {
|
|
iter(iter.value);
|
|
} else {
|
|
function adopt(value) {
|
|
let tmp = value;
|
|
if (!(value instanceof ctor)) {
|
|
const prototype = ctor.prototype;
|
|
tmp = new ctor((arg0) => {
|
|
arg0(arg0);
|
|
});
|
|
}
|
|
return tmp;
|
|
}(iter.value).then(fulfilled, iter);
|
|
const promise = function adopt(value) {
|
|
let tmp = value;
|
|
if (!(value instanceof ctor)) {
|
|
const prototype = ctor.prototype;
|
|
tmp = new ctor((arg0) => {
|
|
arg0(arg0);
|
|
});
|
|
}
|
|
return tmp;
|
|
}(iter.value);
|
|
}
|
|
}
|
|
let items = arg1;
|
|
if (!arg1) {
|
|
items = [];
|
|
}
|
|
const iter = arg3.apply(arg0, items);
|
|
arg3 = iter;
|
|
step(iter.next());
|
|
});
|
|
return _Promise;
|
|
};
|
|
}
|
|
const tmp2 = () => {
|
|
class MessageLoader {
|
|
constructor(arg0, arg1) {
|
|
MessageLoader = this;
|
|
tmp = closure_4(this, MessageLoader);
|
|
this.messages = {};
|
|
this.localeImportMap = arg0;
|
|
this.supportedLocales = Object.keys(arg0);
|
|
this.defaultLocale = arg1;
|
|
this._localeLoadingPromises = {};
|
|
this._parseCache = {};
|
|
set = new Set();
|
|
this._subscribers = set;
|
|
internalIntlMessage = new MessageLoader(closure_2[3]).InternalIntlMessage([], this.defaultLocale);
|
|
this.fallbackMessage = internalIntlMessage;
|
|
if (closure_1.hot) {
|
|
_loop = function _loop(arg0) {
|
|
const self = arg0;
|
|
const hot = hot.hot;
|
|
hot.accept(hot, () => callback(arg0, undefined, undefined, function*() {
|
|
const self = this;
|
|
yield self._loadLocale(closure_0);
|
|
self._parseCache = {};
|
|
}));
|
|
};
|
|
_Object = Object;
|
|
entries = Object.entries(arg0);
|
|
tmp5 = entries;
|
|
tmp6 = entries[Symbol.iterator]();
|
|
num = 2;
|
|
num2 = 0;
|
|
num3 = 1;
|
|
tmp8 = tmp6;
|
|
while (tmp6 !== undefined) {
|
|
tmp9 = closure_3;
|
|
tmp10 = closure_3(tmp7, 2);
|
|
closure_1 = tmp10[1];
|
|
tmp11 = _loop;
|
|
_loopResult = _loop(tmp10[0]);
|
|
// continue
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
const require = MessageLoader;
|
|
let obj = {
|
|
key: "withDebugValues",
|
|
value: function withDebugValues(_debugKeyMap, _localeFileMap) {
|
|
this._debugKeyMap = _debugKeyMap;
|
|
this._localeFileMap = _localeFileMap;
|
|
}
|
|
};
|
|
const items = [obj, , , , , , , , , , ];
|
|
obj = {
|
|
key: "fallbackWith",
|
|
value: function fallbackWith($$loader) {
|
|
const self = this;
|
|
let self2 = this;
|
|
if (null != this) {
|
|
self2 = self2._parentLoader;
|
|
const _Error = Error;
|
|
const error = new Error("Setting `fallbackWith` on MessageLoader created a circular chain that would never resolve");
|
|
throw error;
|
|
}
|
|
self.fallbackLoader = $$loader;
|
|
$$loader._parentLoader = self;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "get",
|
|
value: function get(arg0, defaultLocale) {
|
|
const self = this;
|
|
const messageValue = this.getMessageValue(arg0, defaultLocale);
|
|
if (null != messageValue) {
|
|
return messageValue;
|
|
} else {
|
|
if (self.isLocaleLoading(defaultLocale)) {
|
|
if (!self.isLocaleLoaded(self.defaultLocale)) {
|
|
return self.fallbackMessage;
|
|
}
|
|
}
|
|
const messageValue1 = self.getMessageValue(arg0, self.defaultLocale);
|
|
if (null != messageValue1) {
|
|
return messageValue1;
|
|
} else {
|
|
const fallbackLoader = self.fallbackLoader;
|
|
let value;
|
|
if (null !== fallbackLoader) {
|
|
if (undefined !== fallbackLoader) {
|
|
value = fallbackLoader.get(arg0, defaultLocale);
|
|
}
|
|
}
|
|
if (null != value) {
|
|
return value;
|
|
} else {
|
|
let combined = arg0;
|
|
if (null != self._debugKeyMap) {
|
|
const _HermesInternal = HermesInternal;
|
|
combined = "\"" + self._debugKeyMap[arg0] + "\" (" + arg0 + ")";
|
|
}
|
|
let combined1 = defaultLocale;
|
|
if (null != self._localeFileMap) {
|
|
const _HermesInternal2 = HermesInternal;
|
|
combined1 = "" + defaultLocale + " (" + self._localeFileMap[defaultLocale] + ")";
|
|
}
|
|
if (null != self._localeFileMap) {
|
|
const _HermesInternal3 = HermesInternal;
|
|
defaultLocale = "" + self.defaultLocale + " (" + self._localeFileMap[self.defaultLocale] + ")";
|
|
} else {
|
|
defaultLocale = self.defaultLocale;
|
|
}
|
|
const _console = console;
|
|
const _HermesInternal4 = HermesInternal;
|
|
console.warn("Requested message " + combined + " does not have a value in the requested locale " + combined1 + " nor the default locale " + defaultLocale);
|
|
return self.fallbackMessage;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "getMessageValue",
|
|
value: function getMessageValue(arg0, defaultLocale) {
|
|
const self = this;
|
|
const tmp = this._parseCache[defaultLocale];
|
|
let tmp2;
|
|
if (null !== tmp) {
|
|
if (undefined !== tmp) {
|
|
tmp2 = tmp[arg0];
|
|
}
|
|
}
|
|
if (tmp2) {
|
|
return tmp2;
|
|
} else if (null != self.messages[defaultLocale]) {
|
|
if (null != self.messages[defaultLocale][arg0]) {
|
|
const InternalIntlMessage = MessageLoader(closure_2[3]).InternalIntlMessage;
|
|
const prototype = InternalIntlMessage.prototype;
|
|
const internalIntlMessage = new InternalIntlMessage(tmp4, defaultLocale);
|
|
const _parseCache = self._parseCache;
|
|
let tmp13 = _parseCache[defaultLocale];
|
|
if (null === tmp13) {
|
|
const obj = {};
|
|
_parseCache[defaultLocale] = obj;
|
|
tmp13 = obj;
|
|
}
|
|
tmp13[arg0] = internalIntlMessage;
|
|
return internalIntlMessage;
|
|
}
|
|
} else {
|
|
const supportedLocales = self.supportedLocales;
|
|
if (supportedLocales.includes(defaultLocale)) {
|
|
self._loadLocale(defaultLocale);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "_loadLocale",
|
|
value: function _loadLocale(closure_0) {
|
|
const MessageLoader = closure_0;
|
|
return callback3(this, undefined, undefined, function*() {
|
|
const self = this;
|
|
if (null == self.messages[closure_0]) {
|
|
let current;
|
|
if (null !== self._localeLoadingPromises[closure_0]) {
|
|
if (undefined !== tmp21) {
|
|
current = tmp21.current;
|
|
}
|
|
}
|
|
if (null == current) {
|
|
if (null != self.localeImportMap[closure_0]) {
|
|
const localeImportMap = self.localeImportMap;
|
|
const tmp13 = localeImportMap[closure_0]();
|
|
let initialized;
|
|
if (null !== self._localeLoadingPromises[closure_0]) {
|
|
if (undefined !== tmp14) {
|
|
initialized = tmp14.initialized;
|
|
}
|
|
}
|
|
let obj = { initialized: null !== initialized && undefined !== initialized && initialized, current: tmp13 };
|
|
self._localeLoadingPromises[closure_0] = obj;
|
|
self.messages[closure_0] = yield tmp13.default;
|
|
obj = { initialized: true, current: undefined };
|
|
self._localeLoadingPromises[closure_0] = obj;
|
|
self.emitChange();
|
|
const tmp16 = null !== initialized && undefined !== initialized && initialized;
|
|
const tmp17 = closure_0;
|
|
} else {
|
|
const supportedLocales = self.supportedLocales;
|
|
if (supportedLocales.includes(closure_0)) {
|
|
const _Error = Error;
|
|
const _HermesInternal = HermesInternal;
|
|
const error = new Error("Requested to load locale " + closure_0 + ", which should be supported, but no source for translation data was provided.");
|
|
throw error;
|
|
}
|
|
}
|
|
} else {
|
|
if (null !== self._localeLoadingPromises[closure_0]) {
|
|
if (undefined !== tmp3) {
|
|
current = tmp3.current;
|
|
}
|
|
}
|
|
return yield current;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "emitChange",
|
|
value: function emitChange() {
|
|
const _subscribers = this._subscribers;
|
|
const values = _subscribers.values();
|
|
for (const item10007 of values) {
|
|
let item10007Result = item10007();
|
|
}
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "onChange",
|
|
value: function onChange(arg0) {
|
|
const MessageLoader = arg0;
|
|
const self = this;
|
|
const _subscribers = this._subscribers;
|
|
_subscribers.add(arg0);
|
|
return () => {
|
|
const _subscribers = self._subscribers;
|
|
return _subscribers.delete(arg0);
|
|
};
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "isLocaleLoading",
|
|
value: function isLocaleLoading(defaultLocale) {
|
|
const tmp = this._localeLoadingPromises[defaultLocale];
|
|
let current;
|
|
if (null !== tmp) {
|
|
if (undefined !== tmp) {
|
|
current = tmp.current;
|
|
}
|
|
}
|
|
return null != current;
|
|
}
|
|
};
|
|
items[8] = {
|
|
key: "isLocaleLoaded",
|
|
value: function isLocaleLoaded(currentLocale) {
|
|
const tmp2 = this._localeLoadingPromises[currentLocale];
|
|
let tmp3 = null != tmp2;
|
|
if (tmp3) {
|
|
tmp3 = 0 != tmp2.initialized;
|
|
}
|
|
if (tmp3) {
|
|
tmp3 = !tmp || null == tmp2.current;
|
|
const tmp4 = !tmp || null == tmp2.current;
|
|
}
|
|
return tmp3;
|
|
}
|
|
};
|
|
items[9] = {
|
|
key: "waitForLocaleLoaded",
|
|
value: function waitForLocaleLoaded(defaultLocale, closure_1) {
|
|
return callback3(this, arguments, undefined, function(arg0) {
|
|
const self = this;
|
|
let closure_2 = arguments.length > 1 && undefined !== arguments[1] && arguments[1];
|
|
return function*() {
|
|
if (null == closure_1._localeLoadingPromises[closure_0]) {
|
|
return closure_1._loadLocale(closure_0);
|
|
} else {
|
|
let initialized = tmp.initialized;
|
|
if (initialized) {
|
|
initialized = !closure_2;
|
|
}
|
|
return initialized ? undefined : yield tmp.current;
|
|
}
|
|
}();
|
|
});
|
|
}
|
|
};
|
|
items[10] = {
|
|
key: "waitForDefaultLocale",
|
|
value: function waitForDefaultLocale() {
|
|
return callback3(this, arguments, undefined, function() {
|
|
const self = this;
|
|
let closure_1 = arguments.length > 0 && undefined !== arguments[0] && arguments[0];
|
|
return function*() {
|
|
if (obj) {
|
|
return obj.resume();
|
|
} else {
|
|
return closure_0.waitForLocaleLoaded(closure_0.defaultLocale, closure_1);
|
|
}
|
|
}();
|
|
});
|
|
}
|
|
};
|
|
return callback(MessageLoader, items);
|
|
}();
|
|
let closure_8 = [];
|
|
|
|
export const loadAllMessagesInLocale = function loadAllMessagesInLocale(arg0) {
|
|
const require = arg0;
|
|
return fn(this, undefined, undefined, function*() {
|
|
yield Promise.all(closure_8.map((_loadLocale) => _loadLocale._loadLocale(closure_0)));
|
|
});
|
|
};
|
|
export const waitForAllDefaultIntlMessagesLoaded = function waitForAllDefaultIntlMessagesLoaded() {
|
|
return fn(this, undefined, undefined, function*() {
|
|
yield Promise.all(closure_8.map((waitForDefaultLocale) => waitForDefaultLocale.waitForDefaultLocale()));
|
|
});
|
|
};
|
|
export const createLoader = function createLoader(arg0, arg1) {
|
|
const tmp = new tmp2(arg0, arg1);
|
|
return tmp;
|
|
};
|
|
export const MessageLoader = tmp2;
|