488 lines
19 KiB
TypeScript
488 lines
19 KiB
TypeScript
// Module ID: 16472
|
|
// Function ID: 127209
|
|
// Name: _createForOfIteratorHelperLoose
|
|
// Dependencies: []
|
|
|
|
// Module 16472 (_createForOfIteratorHelperLoose)
|
|
function _createForOfIteratorHelperLoose(@@iterator) {
|
|
let arg1 = Symbol_iterator;
|
|
@@iterator = "undefined" !== typeof Symbol;
|
|
if (Symbol_iterator) {
|
|
const _Symbol = Symbol;
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (!Symbol_iterator) {
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (Symbol_iterator) {
|
|
const iter = Symbol_iterator.call(Symbol_iterator);
|
|
const next = iter.next;
|
|
return next.bind(iter);
|
|
} else {
|
|
const _Array = Array;
|
|
let tmp = Symbol_iterator;
|
|
if (!Array.isArray(Symbol_iterator)) {
|
|
let tmp2;
|
|
if (Symbol_iterator) {
|
|
if ("string" === typeof Symbol_iterator) {
|
|
tmp2 = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const toString = {}.toString;
|
|
const substr = toString.call(Symbol_iterator).slice(8, -1);
|
|
let name = substr;
|
|
if (tmp3) {
|
|
name = Symbol_iterator.constructor.name;
|
|
}
|
|
if ("Map" !== name) {
|
|
if ("Set" !== name) {
|
|
if ("Arguments" === name) {
|
|
let arr = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
|
|
}
|
|
}
|
|
tmp2 = arr;
|
|
}
|
|
const _Array2 = Array;
|
|
arr = Array.from(Symbol_iterator);
|
|
const callResult = toString.call(Symbol_iterator);
|
|
const tmp3 = "Object" === substr && Symbol_iterator.constructor;
|
|
}
|
|
}
|
|
tmp = tmp2;
|
|
if (!tmp2) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
throw typeError;
|
|
}
|
|
}
|
|
if (tmp) {
|
|
arg1 = tmp;
|
|
}
|
|
let closure_1 = 0;
|
|
return () => {
|
|
if (closure_1 >= tmp.length) {
|
|
let obj = { done: true };
|
|
} else {
|
|
obj = { done: false };
|
|
closure_1 = tmp3 + 1;
|
|
obj.value = tmp[+closure_1];
|
|
}
|
|
return obj;
|
|
};
|
|
}
|
|
}
|
|
function _arrayLikeToArray(arg0, arg1) {
|
|
let length;
|
|
if (tmp) {
|
|
length = arg0.length;
|
|
}
|
|
const ArrayResult = Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
ArrayResult[num] = arg0[num];
|
|
}
|
|
return ArrayResult;
|
|
}
|
|
let closure_3 = importDefault(dependencyMap[0]);
|
|
let closure_4 = importDefault(dependencyMap[1]);
|
|
let closure_5 = importDefault(dependencyMap[2]);
|
|
const importDefaultResult = importDefault(dependencyMap[3]);
|
|
const importDefaultResult1 = importDefault(dependencyMap[4]);
|
|
let closure_6 = importDefault(dependencyMap[6]);
|
|
const importDefaultResult2 = importDefault(dependencyMap[5]);
|
|
const importDefaultResult3 = importDefault(dependencyMap[7]);
|
|
const AnalyticEvents = arg1(dependencyMap[9]).AnalyticEvents;
|
|
let importDefaultResult5 = importDefault(dependencyMap[10]);
|
|
importDefaultResult5 = new importDefaultResult5("DispatcherBridge");
|
|
const items = [importDefaultResult2, importDefault(dependencyMap[8]), importDefaultResult3, importDefaultResult, importDefaultResult1];
|
|
let closure_9 = {
|
|
GUILD_MEMBER_ADD(arg0) {
|
|
const obj = {};
|
|
const merged = Object.assign(arg0);
|
|
obj["currentUserId"] = id.getId();
|
|
return obj;
|
|
},
|
|
CONNECTION_OPEN(guilds) {
|
|
return { guilds: guilds.guilds, unavailableGuilds: guilds.unavailableGuilds };
|
|
},
|
|
CACHE_LOADED(guilds) {
|
|
return { guilds: guilds.guilds };
|
|
},
|
|
CACHE_LOADED_LAZY(guilds) {
|
|
return { guilds: guilds.guilds };
|
|
},
|
|
BACKGROUND_SYNC(guilds) {
|
|
return { guilds: guilds.guilds };
|
|
}
|
|
};
|
|
let tmp9 = () => {
|
|
class DispatcherBridge {
|
|
constructor(arg0) {
|
|
DispatcherBridge = this;
|
|
self = this;
|
|
tmp = arg0;
|
|
tmp2 = actionHandler(this, DispatcherBridge);
|
|
map = new Map();
|
|
this.tokenToStore = map;
|
|
this.disabledFromFatalError = false;
|
|
if (0 !== arg0.length) {
|
|
tmp34 = DispatcherBridge;
|
|
tmp35 = FLUX_API;
|
|
num3 = 11;
|
|
FLUX_API = DispatcherBridge(FLUX_API[11]).FLUX_API;
|
|
obj2 = FLUX_API;
|
|
tmp36 = null;
|
|
if (null != FLUX_API) {
|
|
items = [];
|
|
tmp6 = closure_11;
|
|
tmp7 = arg0;
|
|
tmp8 = closure_11(tmp);
|
|
tmp9 = tmp8;
|
|
iter = tmp8();
|
|
iter2 = iter;
|
|
str2 = "";
|
|
str3 = " => [token: ";
|
|
str4 = ", mode: ";
|
|
str5 = "]";
|
|
if (!iter.done) {
|
|
do {
|
|
tmp10 = iter2;
|
|
value = iter2.value;
|
|
name = value.getName();
|
|
tmp12 = FLUX_API;
|
|
result = value.connectWithLibdiscore(obj2);
|
|
tokenToStore = this.tokenToStore;
|
|
result1 = tokenToStore.set(result, value);
|
|
tmp15 = items;
|
|
_HermesInternal = HermesInternal;
|
|
str6 = "";
|
|
tmp16 = name;
|
|
str7 = " => [token: ";
|
|
tmp17 = result;
|
|
str8 = ", mode: ";
|
|
str9 = "]";
|
|
arr = items.push("" + name + " => [token: " + result + ", mode: " + value.getMode() + "]");
|
|
tmp19 = tmp8;
|
|
iter3 = tmp9();
|
|
iter2 = iter3;
|
|
done = iter3.done;
|
|
} while (!done);
|
|
}
|
|
tmp20 = closure_8;
|
|
length = arg0.length;
|
|
tmp21 = items;
|
|
str10 = ", ";
|
|
_HermesInternal2 = HermesInternal;
|
|
str11 = "Connected ";
|
|
str12 = " store(s), mapping: ";
|
|
str13 = ".";
|
|
tmp22 = length;
|
|
str14 = ".";
|
|
infoResult = closure_8.info("Connected " + length + " store(s), mapping: " + items.join(", ") + ".");
|
|
tmp24 = FLUX_API;
|
|
registeredActionTypes = obj2.getRegisteredActionTypes();
|
|
length2 = registeredActionTypes.length;
|
|
_HermesInternal3 = HermesInternal;
|
|
str15 = "Registering ";
|
|
str16 = " bridged action(s): ";
|
|
tmp25 = length2;
|
|
infoResult1 = closure_8.info("Registering " + length2 + " bridged action(s): " + registeredActionTypes.join(", ") + ".");
|
|
actionHandler = function actionHandler(actionHandler, DispatcherBridge) {
|
|
let iter3;
|
|
let length;
|
|
let length2;
|
|
const self = actionHandler;
|
|
if (!self.disabledFromFatalError) {
|
|
const _performance = performance;
|
|
const nowResult = performance.now();
|
|
if (null != closure_9[actionHandler.type]) {
|
|
const _JSON2 = JSON;
|
|
let obj = { type: actionHandler.type };
|
|
const merged = Object.assign(tmp2(actionHandler));
|
|
let json = JSON.stringify(obj);
|
|
} else {
|
|
const _JSON = JSON;
|
|
json = JSON.stringify(actionHandler);
|
|
}
|
|
obj = { kind: "json_stringify_action" };
|
|
const _performance2 = performance;
|
|
obj.durationMillis = performance.now() - nowResult;
|
|
const TelemetryExperiment = self(FLUX_API[12]).TelemetryExperiment;
|
|
const shouldCollectMetricsResult = TelemetryExperiment.shouldCollectMetrics();
|
|
const iter = FLUX_API.dispatchAction(json, shouldCollectMetricsResult);
|
|
if (iter.ok) {
|
|
const _performance3 = performance;
|
|
const diff = performance.now() - nowResult;
|
|
let value = iter.value;
|
|
const metrics = value.metrics;
|
|
const items = [];
|
|
const tmp17 = callback(value.storeResults);
|
|
let iter2 = tmp17();
|
|
if (!iter2.done) {
|
|
do {
|
|
value = iter2.value;
|
|
if (null != value.error) {
|
|
let tmp19 = closure_0;
|
|
let handleStoreErrorResult = closure_0.handleStoreError(value, actionHandler.type);
|
|
} else {
|
|
let arr = items.push(value);
|
|
}
|
|
iter3 = tmp17();
|
|
iter2 = iter3;
|
|
} while (!iter3.done);
|
|
}
|
|
let num3 = 0;
|
|
if (0 < items.length) {
|
|
do {
|
|
let tmp21Result = tmp21(items[num3]);
|
|
num3 = num3 + 1;
|
|
length = items.length;
|
|
} while (num3 < length);
|
|
}
|
|
let num4 = 0;
|
|
if (0 < items.length) {
|
|
do {
|
|
let tmp23 = closure_0;
|
|
let withStoreTokenResult = closure_0.withStoreToken(items[num4].storeToken, actionHandler.type, (doEmitChanges) => {
|
|
doEmitChanges.doEmitChanges(closure_0);
|
|
});
|
|
num4 = num4 + 1;
|
|
length2 = items.length;
|
|
} while (num4 < length2);
|
|
}
|
|
if (null != metrics) {
|
|
if (shouldCollectMetricsResult) {
|
|
const items1 = [obj];
|
|
HermesBuiltin.arraySpread(metrics.timings, 1);
|
|
if (closure_5.get("libdiscore_verbose_telemetry_logging")) {
|
|
const mapped = items1.map((kind) => " - " + kind.kind + ": " + kind.durationMillis + "ms");
|
|
const items2 = [0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001836553781234124, mapped.join("\n")];
|
|
const items3 = [items2, , ];
|
|
const mutations = metrics.mutations;
|
|
const mapped1 = mutations.map((metrics) => {
|
|
const entries = Object.entries(metrics.metrics);
|
|
const found = entries.filter((arg0) => {
|
|
let tmp;
|
|
[, tmp] = arg0;
|
|
return 0 !== tmp;
|
|
});
|
|
const mapped = found.map((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[tmp, tmp2] = arg0;
|
|
return " - " + tmp + ": " + tmp2;
|
|
});
|
|
return " * Record Type: " + metrics.recordType + "\n" + mapped.join("\n");
|
|
});
|
|
const items4 = [956242431, mapped1.join("\n")];
|
|
items3[1] = items4;
|
|
const memory = metrics.memory;
|
|
const mapped2 = memory.map((statistics) => {
|
|
const entries = Object.entries(statistics.statistics);
|
|
const mapped = entries.map((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[tmp, tmp2] = arg0;
|
|
return " - " + tmp + ": " + JSON.stringify(tmp2);
|
|
});
|
|
return " * Record Type: " + statistics.recordType + "\n" + mapped.join("\n");
|
|
});
|
|
const items5 = [0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003376820699032546, mapped2.join("\n")];
|
|
items3[2] = items5;
|
|
const found = items3.filter((arg0) => {
|
|
let arr;
|
|
[, arr] = arg0;
|
|
return arr.length > 0;
|
|
});
|
|
const mapped3 = found.map((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[tmp, tmp2] = arg0;
|
|
return "" + tmp + ":\n" + tmp2;
|
|
});
|
|
const _HermesInternal = HermesInternal;
|
|
closure_8.info("Handling action " + actionHandler.type + " took " + diff + "ms\n" + mapped3.join("\n\n"));
|
|
}
|
|
obj = { action_type: actionHandler.type, total_duration_millis: diff };
|
|
const _JSON3 = JSON;
|
|
obj.timings = JSON.stringify(items1);
|
|
const _JSON4 = JSON;
|
|
obj.mutations = JSON.stringify(metrics.mutations);
|
|
const _JSON5 = JSON;
|
|
obj.memory_usage = JSON.stringify(metrics.memory);
|
|
self(FLUX_API[13]).track(constants.LIBDISCORE_DISPATCH_BRIDGE_TELEMETRY, obj);
|
|
const TelemetryExperiment2 = self(FLUX_API[12]).TelemetryExperiment;
|
|
TelemetryExperiment2.didEmit();
|
|
const obj7 = self(FLUX_API[13]);
|
|
}
|
|
}
|
|
} else {
|
|
self.handleFatalError(iter.error, actionHandler.type);
|
|
}
|
|
}
|
|
};
|
|
tmp27 = self;
|
|
tmp28 = FLUX_API;
|
|
num = 14;
|
|
obj = self(FLUX_API[14]);
|
|
_Object = Object;
|
|
tmp30 = DispatcherBridge;
|
|
fromEntriesResult = Object.fromEntries(registeredActionTypes.map((arg0) => {
|
|
const items = [arg0, actionHandler];
|
|
return items;
|
|
}));
|
|
str17 = "LibDiscoreDispatcherBridge";
|
|
tmp31 = obj;
|
|
registerResult = obj.register("LibDiscoreDispatcherBridge", fromEntriesResult, () => {
|
|
|
|
}, DispatcherBridge(FLUX_API[14]).DispatchBand.Database);
|
|
num2 = 15;
|
|
_default = DispatcherBridge(FLUX_API[15]).default;
|
|
f127232 = _default;
|
|
addChangeListenerResult = _default.addChangeListener(() => {
|
|
if ("active" !== _default.getState()) {
|
|
const _Date = Date;
|
|
let closure_0 = Date.now();
|
|
const result = FLUX_API.flushReplicationStates();
|
|
if (null != result) {
|
|
result.then((arg0) => {
|
|
if (arg0) {
|
|
const _Date = Date;
|
|
const _HermesInternal = HermesInternal;
|
|
closure_8.info("Successfully flushed replication states in " + Date.now() - closure_0 + "ms");
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
tmp4 = closure_8;
|
|
str = "Not initializing DispatcherBridge, because kvStoreApi is unavailable.";
|
|
infoResult2 = closure_8.info("Not initializing DispatcherBridge, because kvStoreApi is unavailable.");
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = DispatcherBridge;
|
|
let obj = {
|
|
key: "handleFatalError",
|
|
value: function handleFatalError(error, type) {
|
|
let done;
|
|
const self = this;
|
|
error = new Error(error);
|
|
const result = this.hasAnyAuthoritativeStore();
|
|
closure_8.error("Fatal dispatch error for action", type, "hasAuthoritativeStore:", result, error);
|
|
let obj = callback(closure_2[16]);
|
|
obj = { actionType: type, hasAuthoritativeStore: result };
|
|
obj.captureException(error, { extra: obj, tags: { "Bool(true)": "isArray", "Bool(true)": "defineProperty" } });
|
|
if (result) {
|
|
const result1 = DispatcherBridge(closure_2[12]).clearLibdiscoreExperimentCache();
|
|
throw error;
|
|
} else {
|
|
closure_8.warn("Disabling DispatcherBridge until restart");
|
|
self.disabledFromFatalError = true;
|
|
const tokenToStore = self.tokenToStore;
|
|
const tmp8 = callback2(tokenToStore.values());
|
|
let iter = tmp8();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
let result2 = value.disableDualReadValidation();
|
|
let iter2 = tmp8();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
const items = [obj, , , ];
|
|
obj = {
|
|
key: "handleStoreError",
|
|
value: function handleStoreError(value, type) {
|
|
const tokenToStore = this.tokenToStore;
|
|
value = tokenToStore.get(value.storeToken);
|
|
let name;
|
|
if (null != value) {
|
|
name = value.getName();
|
|
}
|
|
if (null == name) {
|
|
const _HermesInternal = HermesInternal;
|
|
name = "unknown(token:" + value.storeToken + ")";
|
|
}
|
|
let mode;
|
|
if (null != value) {
|
|
mode = value.getMode();
|
|
}
|
|
let error = value.error;
|
|
let str3 = "unknown store error";
|
|
if (null != error) {
|
|
str3 = error;
|
|
}
|
|
error = new Error(str3);
|
|
closure_8.error("Store", name, "failed to handle action", type, "mode:", mode, error);
|
|
const obj = { actionType: type, storeName: name, storeMode: mode };
|
|
callback(closure_2[16]).captureException(error, { extra: obj, tags: {} });
|
|
if ("typescript-libdiscore-dual-read" !== mode) {
|
|
if ("libdiscore" === mode) {
|
|
const result = DispatcherBridge(closure_2[12]).clearLibdiscoreExperimentCache();
|
|
let error1 = error;
|
|
const obj4 = DispatcherBridge(closure_2[12]);
|
|
} else {
|
|
const _Error = Error;
|
|
const _HermesInternal3 = HermesInternal;
|
|
error1 = new Error("unexpected storeMode '" + mode + "' for store " + name);
|
|
}
|
|
throw error1;
|
|
} else {
|
|
const _HermesInternal2 = HermesInternal;
|
|
closure_8.warn("Store: " + name + " had unexpected error in Rust implementation, disabling moving forward");
|
|
if (null != value) {
|
|
const result1 = value.disableDualReadValidation();
|
|
}
|
|
}
|
|
const obj2 = callback(closure_2[16]);
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "withStoreToken",
|
|
value: function withStoreToken(storeToken, type, arg2) {
|
|
const tokenToStore = this.tokenToStore;
|
|
const value = tokenToStore.get(storeToken);
|
|
if (null == value) {
|
|
closure_8.warn("When dispatching action", type, "we got a store token", storeToken, "that is unknown");
|
|
} else {
|
|
arg2(value);
|
|
}
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "hasAnyAuthoritativeStore",
|
|
value: function hasAnyAuthoritativeStore() {
|
|
const tokenToStore = this.tokenToStore;
|
|
const tmp = callback2(tokenToStore.values());
|
|
let iter = tmp();
|
|
if (!iter.done) {
|
|
const value = iter.value;
|
|
while ("libdiscore" !== value.getMode()) {
|
|
let iter2 = tmp();
|
|
iter = iter2;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
return callback(DispatcherBridge, items);
|
|
}();
|
|
const set = new Set([385816063, 855578623]);
|
|
tmp9 = new tmp9(function filterStores(items) {
|
|
return items.filter((getMode) => set.has(getMode.getMode()));
|
|
}(items));
|
|
const importDefaultResult4 = importDefault(dependencyMap[8]);
|
|
const result = arg1(dependencyMap[17]).fileFinishedImporting("modules/libdiscore/DispatcherBridge.tsx");
|
|
|
|
export default tmp9;
|