1267 lines
38 KiB
TypeScript
1267 lines
38 KiB
TypeScript
// Module ID: 1348
|
|
// Function ID: 15954
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: [15, 17, 18, 57, 5, 6, 7, 1349, 1351, 1352, 1194, 1838, 1850, 653, 3, 1327, 1883, 1902, 1903, 686, 1904, 20, 21, 1905, 22, 566, 2]
|
|
|
|
// Module 1348 (_isNativeReflectConstruct)
|
|
import isDiscordFrontendDevelopment from "isDiscordFrontendDevelopment";
|
|
import _tryLoadAsync from "_tryLoadAsync";
|
|
import ChannelReader from "ChannelReader";
|
|
import _slicedToArray from "_slicedToArray";
|
|
import _classCallCheck from "_classCallCheck";
|
|
import _defineProperties from "_defineProperties";
|
|
import _createForOfIteratorHelperLoose from "_createForOfIteratorHelperLoose";
|
|
import closure_10 from "_createForOfIteratorHelperLoose";
|
|
import _isNativeReflectConstruct from "_isNativeReflectConstruct";
|
|
import _callSuper from "_callSuper";
|
|
import closure_18 from "_isNativeReflectConstruct";
|
|
import closure_19 from "_createForOfIteratorHelperLoose";
|
|
import closure_20 from "_isNativeReflectConstruct";
|
|
import { ChannelTypes } from "ME";
|
|
import importDefaultResult from "_slicedToArray";
|
|
import set from "_inherits";
|
|
|
|
let closure_12;
|
|
let closure_13;
|
|
let closure_14;
|
|
let closure_15;
|
|
let closure_16;
|
|
let closure_17;
|
|
const require = arg1;
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function _createForOfIteratorHelperLoose(iterable) {
|
|
let closure_0 = iterable;
|
|
iterable = "undefined" !== typeof Symbol;
|
|
if (iterable) {
|
|
const _Symbol = Symbol;
|
|
iterable = iterable[Symbol.iterator];
|
|
}
|
|
if (!iterable) {
|
|
iterable = iterable[Symbol.iterator];
|
|
}
|
|
if (iterable) {
|
|
const iter = iterable.call(iterable);
|
|
const next = iter.next;
|
|
return next.bind(iter);
|
|
} else {
|
|
const _Array = Array;
|
|
let tmp = iterable;
|
|
if (!Array.isArray(iterable)) {
|
|
let tmp2;
|
|
if (iterable) {
|
|
if ("string" === typeof iterable) {
|
|
tmp2 = _arrayLikeToArray(iterable, undefined);
|
|
} else {
|
|
const toString = {}.toString;
|
|
const substr = toString.call(iterable).slice(8, -1);
|
|
let name = substr;
|
|
if (tmp3) {
|
|
name = iterable.constructor.name;
|
|
}
|
|
if ("Map" !== name) {
|
|
if ("Set" !== name) {
|
|
if ("Arguments" === name) {
|
|
let arr = _arrayLikeToArray(iterable, undefined);
|
|
} else {
|
|
let obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
|
|
}
|
|
}
|
|
tmp2 = arr;
|
|
}
|
|
const _Array2 = Array;
|
|
arr = Array.from(iterable);
|
|
const callResult = toString.call(iterable);
|
|
tmp3 = "Object" === substr && iterable.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) {
|
|
closure_0 = tmp;
|
|
}
|
|
let c1 = 0;
|
|
return () => {
|
|
if (closure_1 >= length.length) {
|
|
let obj = { done: true };
|
|
} else {
|
|
obj = { done: false };
|
|
closure_1 = tmp3 + 1;
|
|
obj.value = length[+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;
|
|
}
|
|
function ensureGuildLoaded(guild_id, Basic, getBasicChannel) {
|
|
let iter2;
|
|
const _require = guild_id;
|
|
if (null != guild_id) {
|
|
if ("null" !== guild_id) {
|
|
if (!set.has(guild_id)) {
|
|
if (Basic !== closure_40.Basic) {
|
|
const databaseResult = importDefault(1883).database();
|
|
importDefault = databaseResult;
|
|
if (null != databaseResult) {
|
|
const _HermesInternal4 = HermesInternal;
|
|
importDefaultResult.verbose("hydrating guild (guild: " + guild_id + ", trace: " + getBasicChannel + ")");
|
|
const _HermesInternal5 = HermesInternal;
|
|
const result = _require(1902).tryLoadOrResetCacheGateway("ensureGuildLoaded(" + guild_id + ")", () => databaseResult(outer1_2[18]).getSync(closure_1, closure_0), "ensureGuildLoaded");
|
|
if (null == result) {
|
|
set.add(guild_id);
|
|
store.restored(guild_id);
|
|
const _HermesInternal3 = HermesInternal;
|
|
importDefaultResult.log("load returned null; early returning (guild: " + guild_id + ", database: " + databaseResult + ")");
|
|
} else {
|
|
const tmp42 = callback2(result, 2);
|
|
const first = tmp42[0];
|
|
importDefault(1904)(first);
|
|
if (Basic !== closure_40.Basic) {
|
|
closure_39 = closure_39 + 1;
|
|
}
|
|
set.add(guild_id);
|
|
store.restored(guild_id);
|
|
const _HermesInternal = HermesInternal;
|
|
importDefault(20).mark("\u2757", "loaded guild channels (guild: " + guild_id + ")", tmp42[1]);
|
|
const tmp15 = _createForOfIteratorHelperLoose(first);
|
|
let iter = tmp15();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
let _Object = Object;
|
|
let tmp16 = closure_24;
|
|
if (!Object.hasOwn(closure_24, value.id)) {
|
|
let tmp17 = setGuildChannel;
|
|
let tmp18 = callback6;
|
|
let tmp19 = setGuildChannel(callback6(value));
|
|
}
|
|
iter2 = tmp15();
|
|
iter = iter2;
|
|
} while (!iter2.done);
|
|
}
|
|
const _HermesInternal2 = HermesInternal;
|
|
importDefaultResult.verbose("hydration complete (guild: " + guild_id + ", channels: " + first.length + ", guilds_loaded: " + closure_39 + ")");
|
|
const obj2 = importDefault(20);
|
|
}
|
|
const obj3 = _require(1902);
|
|
}
|
|
const obj = importDefault(1883);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function ensureChannelLoaded(channelId, Basic, getBasicChannel) {
|
|
if (!Object.hasOwn(closure_24, channelId)) {
|
|
const _Object = Object;
|
|
if (!Object.hasOwn(closure_26, channelId)) {
|
|
const _Object2 = Object;
|
|
if (!Object.hasOwn(closure_28, channelId)) {
|
|
const _Object3 = Object;
|
|
if (!Object.hasOwn(closure_33, channelId)) {
|
|
if (Basic === closure_40.Full) {
|
|
const basicChannel = store.getBasicChannel(channelId);
|
|
let guild_id;
|
|
if (null != basicChannel) {
|
|
guild_id = basicChannel.guild_id;
|
|
}
|
|
if (null != guild_id) {
|
|
ensureGuildLoaded(basicChannel.guild_id, Basic, getBasicChannel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function deleteGuildChannels(id) {
|
|
let done;
|
|
importDefaultResult.fileOnly("Deleting guild channels for " + id);
|
|
if (null != dependencyMap2[id]) {
|
|
const tmp10 = _createForOfIteratorHelperLoose(importDefault(21).keys(dependencyMap2[id]));
|
|
let iter = tmp10();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
let tmp11 = closure_24;
|
|
delete tmp3[tmp4];
|
|
let iter2 = tmp10();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
delete tmp3[tmp2];
|
|
const obj = importDefault(21);
|
|
}
|
|
if (null != dependencyMap5[id]) {
|
|
delete tmp[tmp2];
|
|
}
|
|
}
|
|
function _getBasicChannel2(channelId) {
|
|
ensureChannelLoaded(channelId, closure_40.Basic, "getBasicChannel");
|
|
let basicChannel = dependencyMap[channelId];
|
|
if (null == basicChannel) {
|
|
basicChannel = dependencyMap3[channelId];
|
|
}
|
|
if (null == basicChannel) {
|
|
basicChannel = dependencyMap4[channelId];
|
|
}
|
|
if (null == basicChannel) {
|
|
basicChannel = dependencyMap7[channelId];
|
|
}
|
|
if (null == basicChannel) {
|
|
basicChannel = store.getBasicChannel(channelId);
|
|
}
|
|
return basicChannel;
|
|
}
|
|
function _getChannel(channelId) {
|
|
ensureChannelLoaded(channelId, closure_40.Full, "getChannel");
|
|
let tmp2 = dependencyMap[channelId];
|
|
if (null == tmp2) {
|
|
tmp2 = dependencyMap3[channelId];
|
|
}
|
|
if (null == tmp2) {
|
|
tmp2 = dependencyMap4[channelId];
|
|
}
|
|
if (null == tmp2) {
|
|
tmp2 = dependencyMap7[channelId];
|
|
}
|
|
if (null == tmp2) {
|
|
tmp2 = table2[channelId];
|
|
}
|
|
return tmp2;
|
|
}
|
|
function setChannel(isPrivate) {
|
|
if (isPrivate.isPrivate()) {
|
|
const id = isPrivate.id;
|
|
delete tmp2[tmp];
|
|
setPrivateChannel(isPrivate);
|
|
} else if (isPrivate.isThread()) {
|
|
setThread(isPrivate);
|
|
} else if (set.has(isPrivate.type)) {
|
|
setGuildChannel(isPrivate);
|
|
}
|
|
}
|
|
function setPrivateChannel(recipients) {
|
|
recipients = recipients.recipients;
|
|
if (null != recipients.find((arg0) => outer1_1(outer1_2[23])(arg0))) {
|
|
return false;
|
|
} else {
|
|
closure_26[recipients.id] = recipients;
|
|
if (recipients.type === ChannelTypes.DM) {
|
|
closure_30[recipients.getRecipientId()] = recipients.id;
|
|
}
|
|
closure_31 = closure_31 + 1;
|
|
}
|
|
}
|
|
function setThread(value) {
|
|
let id;
|
|
let merge;
|
|
let obj = {};
|
|
let nsfw;
|
|
({ id, merge } = value);
|
|
if (null != dependencyMap[value.parent_id]) {
|
|
nsfw = tmp.nsfw;
|
|
}
|
|
obj.nsfw = true === nsfw;
|
|
let type;
|
|
if (null != dependencyMap[value.parent_id]) {
|
|
type = tmp.type;
|
|
}
|
|
obj.parentChannelThreadType = type;
|
|
closure_28[id] = merge(obj);
|
|
if (value.isScheduledForDeletion()) {
|
|
obj = { type: "THREAD_DELETE", channel: value };
|
|
importDefault(686).dispatch(obj);
|
|
const obj2 = importDefault(686);
|
|
}
|
|
}
|
|
function setGuildChannel(value) {
|
|
let guild_id;
|
|
let id;
|
|
({ id, guild_id } = value);
|
|
closure_24[id] = value;
|
|
let obj = dependencyMap2[guild_id];
|
|
if (null == obj) {
|
|
obj = {};
|
|
}
|
|
dependencyMap2[guild_id] = obj;
|
|
dependencyMap2[guild_id][id] = value;
|
|
let num = 0;
|
|
if (null != dependencyMap6[guild_id]) {
|
|
num = tmp5;
|
|
}
|
|
dependencyMap6[guild_id] = num + 1;
|
|
if (null != value.linkedLobby) {
|
|
obj = dependencyMap5[guild_id];
|
|
if (null == obj) {
|
|
obj = {};
|
|
}
|
|
dependencyMap5[guild_id] = obj;
|
|
dependencyMap5[guild_id][id] = value;
|
|
const tmp7 = dependencyMap5;
|
|
} else if (null != dependencyMap5[guild_id]) {
|
|
delete tmp2[tmp];
|
|
}
|
|
}
|
|
function handleOneGuildCreate(arg0) {
|
|
let channels;
|
|
let done;
|
|
let done2;
|
|
let done3;
|
|
let id;
|
|
let threads;
|
|
({ id, channels, threads } = arg0);
|
|
const op = channels.op;
|
|
if ("full_sync" === op) {
|
|
const _HermesInternal = HermesInternal;
|
|
importDefaultResult.fileOnly("ConnectionOpen contained full channels for " + id + " #:" + channels.items.length);
|
|
deleteGuildChannels(id);
|
|
set.add(id);
|
|
store.restored(id);
|
|
const tmp23 = _createForOfIteratorHelperLoose(channels.items);
|
|
let iter5 = tmp23();
|
|
if (!iter5.done) {
|
|
do {
|
|
let tmp24 = setGuildChannel;
|
|
let tmp25 = setGuildChannel(iter5.value);
|
|
let iter6 = tmp23();
|
|
iter5 = iter6;
|
|
done2 = iter6.done;
|
|
} while (!done2);
|
|
}
|
|
} else if ("update" === op) {
|
|
if (tmp) {
|
|
store.invalidate(id);
|
|
}
|
|
const tmp5 = _createForOfIteratorHelperLoose(channels.deletes);
|
|
let iter = tmp5();
|
|
if (!iter.done) {
|
|
do {
|
|
let tmp6 = deleteChannel;
|
|
let tmp7 = dependencyMap;
|
|
let tmp8 = deleteChannel(dependencyMap[iter.value]);
|
|
let iter2 = tmp5();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
const tmp10 = _createForOfIteratorHelperLoose(channels.writes);
|
|
let iter3 = tmp10();
|
|
if (!iter3.done) {
|
|
setGuildChannel(iter3.value);
|
|
const iter4 = tmp10();
|
|
iter3 = iter4;
|
|
}
|
|
tmp = channels.writes.length > 0 || channels.deletes.length > 0;
|
|
}
|
|
if (null != threads) {
|
|
const tmp27 = _createForOfIteratorHelperLoose(threads);
|
|
let iter7 = tmp27();
|
|
if (!iter7.done) {
|
|
do {
|
|
let tmp28 = setThread;
|
|
let tmp29 = setThread(iter7.value);
|
|
let iter8 = tmp27();
|
|
iter7 = iter8;
|
|
done3 = iter8.done;
|
|
} while (!done3);
|
|
}
|
|
}
|
|
}
|
|
function handleThreadCreateOrUpdate(channel) {
|
|
if (set3.has(channel.channel.type)) {
|
|
let obj = _getChannel(channel.channel.id);
|
|
if (null == obj) {
|
|
let channel2 = channel.channel;
|
|
} else {
|
|
obj = {};
|
|
channel = channel.channel;
|
|
const merged = Object.assign(channel.toJS());
|
|
let bitrate = channel.channel.bitrate;
|
|
if (null == bitrate) {
|
|
bitrate = obj.bitrate;
|
|
}
|
|
obj["bitrate"] = bitrate;
|
|
channel2 = obj.merge(obj);
|
|
}
|
|
setChannel(channel2);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
function handleLoadArchivedThreadsSuccess(threads) {
|
|
threads = threads.threads;
|
|
const item = threads.forEach((type) => {
|
|
if (outer1_16.has(type.type)) {
|
|
outer1_49(outer1_12(type));
|
|
}
|
|
});
|
|
}
|
|
function deleteChannel(guild_id) {
|
|
if (null != guild_id) {
|
|
guild_id = guild_id.guild_id;
|
|
if (guild_id.id in closure_26) {
|
|
const id = guild_id.id;
|
|
delete tmp3[tmp];
|
|
}
|
|
if (guild_id.id in closure_24) {
|
|
const id2 = guild_id.id;
|
|
delete tmp3[tmp];
|
|
}
|
|
if (guild_id.id in closure_28) {
|
|
const id3 = guild_id.id;
|
|
delete tmp3[tmp];
|
|
}
|
|
if (null != guild_id) {
|
|
let tmp10 = null != dependencyMap2[guild_id];
|
|
if (tmp10) {
|
|
tmp10 = guild_id.id in dependencyMap2[guild_id];
|
|
}
|
|
if (tmp10) {
|
|
const id4 = guild_id.id;
|
|
delete tmp3[tmp];
|
|
}
|
|
let tmp15 = null != dependencyMap5[guild_id];
|
|
if (tmp15) {
|
|
tmp15 = guild_id.id in dependencyMap5[guild_id];
|
|
}
|
|
if (tmp15) {
|
|
const id5 = guild_id.id;
|
|
delete tmp2[tmp];
|
|
}
|
|
}
|
|
if (null != guild_id.guild_id) {
|
|
if (!set2.has(guild_id.type)) {
|
|
let num = 0;
|
|
if (null != dependencyMap6[guild_id.guild_id]) {
|
|
num = tmp22;
|
|
}
|
|
dependencyMap6[guild_id.guild_id] = num + 1;
|
|
const tmp20 = dependencyMap6;
|
|
}
|
|
}
|
|
if (callback5(guild_id.type)) {
|
|
closure_31 = closure_31 + 1;
|
|
}
|
|
}
|
|
}
|
|
function handleDeleteChannel(channel) {
|
|
channel = channel.channel;
|
|
let obj = dependencyMap[channel.id];
|
|
if (null == obj) {
|
|
obj = dependencyMap3[channel.id];
|
|
}
|
|
if (null == obj) {
|
|
obj = dependencyMap4[channel.id];
|
|
}
|
|
if (null == obj) {
|
|
return false;
|
|
} else {
|
|
deleteChannel(obj);
|
|
if (!("basicPermissions" in obj)) {
|
|
if (obj.type === ChannelTypes.DM) {
|
|
if (table[obj.getRecipientId(obj)] === obj.id) {
|
|
delete tmp[tmp2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function handleLoadMessages(messages) {
|
|
let iter2;
|
|
const tmp = _createForOfIteratorHelperLoose(messages.messages);
|
|
let iter = tmp();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
let hasItem = null != value.thread;
|
|
if (hasItem) {
|
|
let tmp3 = closure_28;
|
|
hasItem = !(value.thread.id in closure_28);
|
|
}
|
|
if (hasItem) {
|
|
let tmp4 = set3;
|
|
hasItem = set3.has(value.thread.type);
|
|
}
|
|
if (hasItem) {
|
|
let tmp5 = setThread;
|
|
let tmp6 = callback4;
|
|
let tmp7 = setThread(callback4(value.thread));
|
|
}
|
|
iter2 = tmp();
|
|
iter = iter2;
|
|
} while (!iter2.done);
|
|
}
|
|
}
|
|
function handleSearchMessagesSuccess(data) {
|
|
data = data.data;
|
|
let item = data.forEach((arg0) => {
|
|
let channels;
|
|
let messages;
|
|
let threads;
|
|
({ messages, threads, channels } = arg0);
|
|
let item = messages.forEach((arr) => {
|
|
const item = arr.forEach((thread) => {
|
|
outer3_55(thread.thread);
|
|
});
|
|
});
|
|
const item1 = threads.forEach(outer1_55);
|
|
const item2 = channels.forEach((id) => {
|
|
const obj = outer2_12(id);
|
|
const tmp = null != outer2_48(id.id);
|
|
if (!obj.isPrivate()) {
|
|
if (!tmp) {
|
|
outer2_49(obj);
|
|
}
|
|
} else {
|
|
outer2_37[obj.id] = obj;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
function addThreadIfMissing(id) {
|
|
let hasItem = null != id;
|
|
if (hasItem) {
|
|
hasItem = !(id.id in closure_28);
|
|
}
|
|
if (hasItem) {
|
|
hasItem = set3.has(id.type);
|
|
}
|
|
if (hasItem) {
|
|
setThread(callback4(id));
|
|
}
|
|
}
|
|
function handleFavoritesUpdate() {
|
|
let closure_33 = {};
|
|
for (const key10006 in _isNativeReflectConstruct.getFavoriteChannels()) {
|
|
let tmp2 = key10006;
|
|
let tmp3 = store2;
|
|
let categoryRecord = store2.getCategoryRecord(key10006);
|
|
if (null == categoryRecord) {
|
|
continue;
|
|
} else {
|
|
let tmp = closure_33;
|
|
closure_33[key10006] = categoryRecord;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
function guildChannelCount(id) {
|
|
let length = null;
|
|
if (null != dependencyMap2[id]) {
|
|
const _Object = Object;
|
|
length = Object.keys(dependencyMap2[id]).length;
|
|
}
|
|
return length;
|
|
}
|
|
({ createChannelRecordFromServer: closure_12, isPrivate: closure_13, GUILD_CHANNEL_TYPES: closure_14, THREAD_CHANNEL_TYPES: closure_15, ALL_CHANNEL_TYPES: closure_16, castChannelRecord: closure_17 } = _callSuper);
|
|
importDefaultResult = new importDefaultResult("ChannelStore");
|
|
let closure_23 = {};
|
|
let closure_24 = {};
|
|
let closure_25 = {};
|
|
let closure_26 = {};
|
|
let c27 = null;
|
|
let closure_28 = {};
|
|
let closure_29 = {};
|
|
let closure_30 = {};
|
|
let c31 = 0;
|
|
let closure_32 = {};
|
|
let closure_33 = {};
|
|
let set = new Set();
|
|
let closure_35 = {};
|
|
let c36 = 0;
|
|
let closure_37 = {};
|
|
let c38 = 0;
|
|
let c39 = 0;
|
|
let closure_40 = { Basic: 0, [0]: "Basic", Full: 1, [1]: "Full" };
|
|
let tmp7 = ((Store) => {
|
|
class ChannelStore {
|
|
constructor() {
|
|
self = this;
|
|
tmp = outer1_8(this, ChannelStore);
|
|
obj = outer1_4(ChannelStore);
|
|
tmp2 = outer1_3;
|
|
if (outer1_41()) {
|
|
tmp6 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp7 = outer1_4;
|
|
tmp8 = arguments;
|
|
constructResult = Reflect.construct(obj, arguments, outer1_4(self).constructor);
|
|
} else {
|
|
tmp3 = arguments;
|
|
tmp4 = arguments;
|
|
constructResult = obj(...arguments);
|
|
}
|
|
return tmp2(self, constructResult);
|
|
}
|
|
}
|
|
callback(ChannelStore, Store);
|
|
let obj = {
|
|
key: "initialize",
|
|
value() {
|
|
this.waitFor(outer1_18, outer1_10, outer1_11, outer1_19, outer1_20);
|
|
const items = [outer1_11];
|
|
this.syncWith(items, outer1_56);
|
|
}
|
|
};
|
|
let items = [obj, , , , , , , , , , , , , , , , , , , , ];
|
|
obj = {
|
|
key: "hasChannel",
|
|
value(arg0) {
|
|
return null != outer1_47(arg0);
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "getBasicChannel",
|
|
value(arg0) {
|
|
if (null != arg0) {
|
|
return outer1_47(arg0);
|
|
}
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "getChannel",
|
|
value(arg0) {
|
|
if (null != arg0) {
|
|
return outer1_48(arg0);
|
|
}
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "loadAllGuildAndPrivateChannelsFromDisk",
|
|
value() {
|
|
let done;
|
|
const tmp = outer1_42(outer1_19.getGuildIds());
|
|
let iter = tmp();
|
|
if (!iter.done) {
|
|
do {
|
|
let tmp2 = outer1_44;
|
|
let tmp3 = outer1_40;
|
|
let tmp4 = outer1_44(iter.value, outer1_40.Full, "loadAllGuildAndPrivateChannelsFromDisk");
|
|
let iter2 = tmp();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
const merged = Object.assign(outer1_24);
|
|
const merged1 = Object.assign(outer1_26);
|
|
return {};
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "getChannelIds",
|
|
value(arg0) {
|
|
outer1_44(arg0, outer1_40.Basic, "getChannelIds");
|
|
if (null == arg0) {
|
|
let keys = outer1_1(outer1_2[22]).keys(outer1_26);
|
|
const obj2 = outer1_1(outer1_2[22]);
|
|
} else {
|
|
let guildBasicChannels = outer1_10.getGuildBasicChannels(arg0);
|
|
if (null == guildBasicChannels) {
|
|
guildBasicChannels = outer1_25[arg0];
|
|
}
|
|
if (null == guildBasicChannels) {
|
|
guildBasicChannels = outer1_23;
|
|
}
|
|
keys = outer1_1(outer1_2[22]).keys(guildBasicChannels);
|
|
const obj = outer1_1(outer1_2[22]);
|
|
}
|
|
return keys;
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "getMutablePrivateChannels",
|
|
value() {
|
|
return outer1_26;
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "getMutableBasicGuildChannelsForGuild",
|
|
value(arg0) {
|
|
outer1_44(arg0, outer1_40.Basic, "getMutableBasicGuildChannelsForGuild");
|
|
let guildBasicChannels = outer1_10.getGuildBasicChannels(arg0);
|
|
if (null == guildBasicChannels) {
|
|
guildBasicChannels = outer1_25[arg0];
|
|
}
|
|
if (null == guildBasicChannels) {
|
|
guildBasicChannels = outer1_23;
|
|
}
|
|
return guildBasicChannels;
|
|
}
|
|
};
|
|
items[8] = {
|
|
key: "getMutableGuildChannelsForGuild",
|
|
value(arg0) {
|
|
outer1_44(arg0, outer1_40.Full, "getMutableGuildChannelsForGuild");
|
|
let tmp2 = outer1_25[arg0];
|
|
if (null == tmp2) {
|
|
tmp2 = outer1_23;
|
|
}
|
|
return tmp2;
|
|
}
|
|
};
|
|
items[9] = {
|
|
key: "getSortedLinkedChannelsForGuild",
|
|
value(arg0) {
|
|
let tmp = outer1_29[arg0];
|
|
if (null == tmp) {
|
|
tmp = outer1_23;
|
|
}
|
|
const values = outer1_1(outer1_2[24]).values(tmp);
|
|
return values.sort((id, id2) => outer2_1(outer2_2[22]).compare(id.id, id2.id));
|
|
}
|
|
};
|
|
items[10] = {
|
|
key: "getSortedPrivateChannels",
|
|
value() {
|
|
const values = outer1_1(outer1_2[24])(outer1_26).values();
|
|
const sorted = values.sort((lastMessageId, lastMessageId2) => outer2_1(outer2_2[22]).compare(lastMessageId.lastMessageId, lastMessageId2.lastMessageId));
|
|
const obj = outer1_1(outer1_2[24])(outer1_26);
|
|
return sorted.reverse().value();
|
|
}
|
|
};
|
|
items[11] = {
|
|
key: "getDMFromUserId",
|
|
value(arg0) {
|
|
if (null != arg0) {
|
|
return outer1_30[arg0];
|
|
}
|
|
}
|
|
};
|
|
items[12] = {
|
|
key: "getDMChannelFromUserId",
|
|
value(arg0) {
|
|
const self = this;
|
|
if (null != arg0) {
|
|
return self.getChannel(outer1_30[arg0]);
|
|
}
|
|
}
|
|
};
|
|
items[13] = {
|
|
key: "getMutableDMsByUserIds",
|
|
value() {
|
|
return outer1_30;
|
|
}
|
|
};
|
|
items[14] = {
|
|
key: "getDMUserIds",
|
|
value() {
|
|
return outer1_1(outer1_2[22]).keys(outer1_30);
|
|
}
|
|
};
|
|
items[15] = {
|
|
key: "getPrivateChannelsVersion",
|
|
value() {
|
|
return outer1_31;
|
|
}
|
|
};
|
|
items[16] = {
|
|
key: "getGuildChannelsVersion",
|
|
value(arg0) {
|
|
let num = 0;
|
|
if (null != outer1_32[arg0]) {
|
|
num = tmp;
|
|
}
|
|
return num;
|
|
}
|
|
};
|
|
items[17] = {
|
|
key: "getAllThreadsForParent",
|
|
value(arg0) {
|
|
let closure_0 = arg0;
|
|
const values = outer1_1(outer1_2[24]).values(outer1_28);
|
|
return values.filter((parent_id) => parent_id.parent_id === closure_0);
|
|
}
|
|
};
|
|
items[18] = {
|
|
key: "getAllThreadsForGuild",
|
|
value(arg0) {
|
|
let closure_0 = arg0;
|
|
const values = outer1_1(outer1_2[24]).values(outer1_28);
|
|
return values.filter((guild_id) => guild_id.guild_id === closure_0);
|
|
}
|
|
};
|
|
items[19] = {
|
|
key: "getInitialOverlayState",
|
|
value() {
|
|
const merged = Object.assign(outer1_24);
|
|
const merged1 = Object.assign(outer1_26);
|
|
const merged2 = Object.assign(outer1_28);
|
|
return {};
|
|
}
|
|
};
|
|
items[20] = {
|
|
key: "getDebugInfo",
|
|
value() {
|
|
const obj = { loadedGuildIds: Array.from(outer1_34).sort(outer1_1(outer1_2[22]).compare) };
|
|
const keys = Object.keys(outer1_35);
|
|
obj.pendingGuildLoads = keys.sort(outer1_1(outer1_2[22]).compare);
|
|
const keys1 = Object.keys(outer1_25);
|
|
const sorted = keys1.sort(outer1_1(outer1_2[22]).compare);
|
|
obj.guildSizes = sorted.map((arg0) => "" + arg0 + ": " + outer2_57(arg0));
|
|
return obj;
|
|
}
|
|
};
|
|
return callback3(ChannelStore, items);
|
|
})(require("initialize").Store);
|
|
tmp7.displayName = "ChannelStore";
|
|
tmp7 = new tmp7(require("dispatcher"), {
|
|
BACKGROUND_SYNC: function handleBackgroundSync(guilds) {
|
|
guilds = guilds.guilds;
|
|
let closure_0 = closure_25;
|
|
let closure_24 = {};
|
|
closure_25 = {};
|
|
let closure_32 = {};
|
|
let closure_29 = {};
|
|
let item = guilds.forEach((data_mode) => {
|
|
const dependencyMap = data_mode;
|
|
if ("unavailable" === data_mode.data_mode) {
|
|
const _HermesInternal2 = HermesInternal;
|
|
outer1_22.fileOnly("Restoring guild channels b/c unavailable in bg sync, for " + data_mode.id + " #:" + outer1_57(data_mode.id));
|
|
const item = outer1_1(outer1_2[24]).forEach(dependencyMap[data_mode.id], outer1_52);
|
|
const arr4 = outer1_1(outer1_2[24]);
|
|
} else if ("partial" === data_mode.data_mode) {
|
|
const _HermesInternal = HermesInternal;
|
|
outer1_22.fileOnly("Restoring guild channels b/c partial in bg sync, for " + data_mode.id + " #:" + outer1_57(data_mode.id));
|
|
const item1 = outer1_1(outer1_2[24]).forEach(dependencyMap[data_mode.id], outer1_52);
|
|
let deleted_channel_ids = data_mode.partial_updates.deleted_channel_ids;
|
|
if (null == deleted_channel_ids) {
|
|
deleted_channel_ids = [];
|
|
}
|
|
if (deleted_channel_ids.length > 0) {
|
|
outer1_44(data_mode.id, outer1_40.Full, "handleBackgroundSync");
|
|
const item2 = deleted_channel_ids.forEach((arg0) => {
|
|
outer2_54(table[arg0]);
|
|
});
|
|
}
|
|
const channels = data_mode.partial_updates.channels;
|
|
if (null != channels) {
|
|
const item3 = channels.forEach((arg0) => {
|
|
outer2_52(outer2_12(arg0, data_mode.id));
|
|
});
|
|
}
|
|
const arr = outer1_1(outer1_2[24]);
|
|
} else {
|
|
const _HermesInternal3 = HermesInternal;
|
|
outer1_22.fileOnly("BG sync contained full channels for " + data_mode.id + " #:" + data_mode.channels.length);
|
|
outer1_46(data_mode.id);
|
|
outer1_34.add(data_mode.id);
|
|
outer1_10.restored(data_mode.id);
|
|
const channels1 = data_mode.channels;
|
|
const item4 = channels1.forEach((arg0) => {
|
|
outer2_52(outer2_12(arg0, data_mode.id));
|
|
});
|
|
}
|
|
});
|
|
},
|
|
CACHE_LOADED_LAZY: function handleLazyCacheLoaded(guilds) {
|
|
let arr;
|
|
let iter4;
|
|
let tmp4;
|
|
closure_38 = Math.max(closure_38, guilds.guilds.length);
|
|
const tmp = _createForOfIteratorHelperLoose(guilds.guildChannels);
|
|
let iter = tmp();
|
|
if (!iter.done) {
|
|
do {
|
|
let tmp2 = callback2;
|
|
let tmp3 = callback2(iter.value, 2);
|
|
[tmp4, arr] = tmp3;
|
|
let tmp5 = importDefaultResult;
|
|
let _HermesInternal = HermesInternal;
|
|
let fileOnlyResult = importDefaultResult.fileOnly("Lazy cache contained full guild channels for " + tmp4 + " #:" + arr.length);
|
|
let tmp7 = set;
|
|
let addResult = set.add(tmp4);
|
|
let tmp9 = _createForOfIteratorHelperLoose;
|
|
let tmp10 = _createForOfIteratorHelperLoose(arr);
|
|
let iter2 = tmp10();
|
|
if (!iter2.done) {
|
|
do {
|
|
let tmp11 = setChannel;
|
|
let tmp12 = callback6;
|
|
let tmp13 = setChannel(callback6(iter2.value));
|
|
let iter3 = tmp10();
|
|
iter2 = iter3;
|
|
done = iter3.done;
|
|
} while (!done);
|
|
}
|
|
iter4 = tmp();
|
|
iter = iter4;
|
|
} while (!iter4.done);
|
|
}
|
|
},
|
|
CACHE_LOADED: function handleCacheLoaded(guilds) {
|
|
closure_38 = Math.max(closure_38, guilds.guilds.length);
|
|
const initialGuildChannels = guilds.initialGuildChannels;
|
|
const items = [guilds.privateChannels, initialGuildChannels];
|
|
for (let num = 0; num < items.length; num = num + 1) {
|
|
let tmp = _createForOfIteratorHelperLoose;
|
|
let tmp2 = _createForOfIteratorHelperLoose(items[num]);
|
|
let iter = tmp2();
|
|
if (!iter.done) {
|
|
do {
|
|
let tmp3 = setChannel;
|
|
let tmp4 = require;
|
|
let tmp5 = dependencyMap;
|
|
let obj = require(1904) /* _createForOfIteratorHelperLoose */;
|
|
let tmp6 = callback6;
|
|
let tmp7 = setChannel(obj.deserializeChannel(callback6(iter.value)));
|
|
let iter2 = tmp2();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
}
|
|
const first = initialGuildChannels[0];
|
|
let guild_id;
|
|
if (null != first) {
|
|
guild_id = first.guild_id;
|
|
}
|
|
if (null != guild_id) {
|
|
const _HermesInternal = HermesInternal;
|
|
importDefaultResult.fileOnly("Early cache contained full guild channels for " + guild_id);
|
|
set.add(guild_id);
|
|
}
|
|
},
|
|
CHANNEL_CREATE: function handleChannelCreate(channel) {
|
|
setChannel(channel.channel);
|
|
},
|
|
CHANNEL_DELETE: handleDeleteChannel,
|
|
CHANNEL_RECIPIENT_ADD: function handleAddRecipient(channelId) {
|
|
const obj = _getChannel(channelId.channelId);
|
|
let tmp2 = null == obj;
|
|
id = id.getId();
|
|
if (!tmp2) {
|
|
tmp2 = !obj.isPrivate();
|
|
}
|
|
let flag = !tmp2;
|
|
if (!tmp2) {
|
|
setChannel(obj.addRecipient(channelId.user.id, channelId.nick, id));
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
},
|
|
CHANNEL_RECIPIENT_REMOVE: function handleRemoveRecipient(channelId) {
|
|
const obj = _getChannel(channelId.channelId);
|
|
const tmp = null == obj || !obj.isPrivate();
|
|
let flag = !tmp;
|
|
if (!tmp) {
|
|
setChannel(obj.removeRecipient(channelId.user.id));
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
},
|
|
CHANNEL_UPDATES: function handleUpdateChannels(channels) {
|
|
let done;
|
|
channels = channels.channels;
|
|
const tmp2 = _createForOfIteratorHelperLoose(channels.channels);
|
|
let iter = tmp2();
|
|
if (!iter.done) {
|
|
do {
|
|
let tmp3 = setChannel;
|
|
let tmp4 = setChannel(iter.value);
|
|
let iter2 = tmp2();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
if (someResult) {
|
|
const _Object = Object;
|
|
const values = Object.values(closure_28);
|
|
const item = values.forEach((arg0) => {
|
|
outer1_49(arg0);
|
|
});
|
|
}
|
|
},
|
|
CONNECTION_OPEN_SUPPLEMENTAL: function handleConnectionOpenSupplemental(lazyPrivateChannels) {
|
|
lazyPrivateChannels = lazyPrivateChannels.lazyPrivateChannels;
|
|
if (null != _null) {
|
|
let closure_26 = {};
|
|
const item = _null.forEach(setPrivateChannel);
|
|
}
|
|
const item1 = lazyPrivateChannels.forEach(setPrivateChannel);
|
|
},
|
|
CONNECTION_OPEN: function handleConnectionOpen(guilds) {
|
|
let c27;
|
|
let initialPrivateChannels;
|
|
let iter2;
|
|
let closure_30 = {};
|
|
let closure_24 = {};
|
|
let closure_25 = {};
|
|
let closure_29 = {};
|
|
let closure_28 = {};
|
|
let closure_32 = {};
|
|
let closure_37 = {};
|
|
let closure_35 = {};
|
|
let closure_36 = Date.now();
|
|
({ initialPrivateChannels: c27, initialPrivateChannels } = guilds);
|
|
const item = initialPrivateChannels.forEach(setPrivateChannel);
|
|
const tmp3 = _createForOfIteratorHelperLoose(guilds.guilds);
|
|
let iter = tmp3();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
if ("partial" === value.dataMode) {
|
|
let tmp4 = importDefault;
|
|
let tmp5 = dependencyMap;
|
|
let arr = importDefault(22);
|
|
let tmp6 = setGuildChannel;
|
|
let item1 = arr.forEach(tmp[value.id], setGuildChannel);
|
|
let tmp8 = importDefaultResult;
|
|
let tmp9 = guildChannelCount;
|
|
let _HermesInternal = HermesInternal;
|
|
let fileOnlyResult = importDefaultResult.fileOnly("Restoring guild channels for " + value.id + " #:" + guildChannelCount(value.id));
|
|
}
|
|
let tmp11 = handleOneGuildCreate;
|
|
let tmp12 = handleOneGuildCreate(value);
|
|
iter2 = tmp3();
|
|
iter = iter2;
|
|
} while (!iter2.done);
|
|
}
|
|
handleFavoritesUpdate();
|
|
},
|
|
CHANNEL_PERMISSIONS_PUT_OVERWRITE_SUCCESS: function handlePutOverwriteSuccess(overwrite) {
|
|
overwrite = overwrite.overwrite;
|
|
let obj = _getChannel(overwrite.channelId);
|
|
if (null == obj) {
|
|
return false;
|
|
} else {
|
|
obj = {};
|
|
const merged = Object.assign(obj.permissionOverwrites);
|
|
obj[overwrite.id] = overwrite;
|
|
setChannel(obj.set("permissionOverwrites", obj));
|
|
}
|
|
},
|
|
CHANNEL_PERMISSIONS_DELETE_OVERWRITE_SUCCESS: function handleDeleteOverwriteSuccess(channelId) {
|
|
let obj = _getChannel(channelId.channelId);
|
|
if (null == obj) {
|
|
return false;
|
|
} else {
|
|
obj = {};
|
|
const merged = Object.assign(obj.permissionOverwrites);
|
|
delete tmp2[tmp];
|
|
setChannel(obj.set("permissionOverwrites", obj));
|
|
}
|
|
},
|
|
GUILD_CREATE: function handleCreateGuild(guild) {
|
|
handleOneGuildCreate(guild.guild);
|
|
},
|
|
GUILD_DELETE: function handleGuildDelete(guild) {
|
|
importDefaultResult.fileOnly("GuildDelete of " + guild.guild.id);
|
|
deleteGuildChannels(guild.guild.id);
|
|
set.delete(guild.guild.id);
|
|
store.invalidate(guild.guild.id);
|
|
},
|
|
LOAD_ARCHIVED_THREADS_SUCCESS: handleLoadArchivedThreadsSuccess,
|
|
LOAD_CHANNELS: function handleLoadChannels(channels) {
|
|
let guildId;
|
|
let iter5;
|
|
const tmp = _createForOfIteratorHelperLoose(channels.channels);
|
|
const iter = tmp();
|
|
let iter2 = iter;
|
|
if (!iter.done) {
|
|
do {
|
|
({ guildId, channels } = iter2.value);
|
|
let tmp2 = importDefaultResult;
|
|
let _HermesInternal = HermesInternal;
|
|
let fileOnlyResult = importDefaultResult.fileOnly("Lazy loaded guild channels for " + guildId);
|
|
let tmp4 = importDefault;
|
|
let tmp5 = dependencyMap;
|
|
let tmp6 = importDefault(1904)(channels);
|
|
let tmp7 = set;
|
|
let addResult = set.add(guildId);
|
|
let tmp9 = store;
|
|
let restoredResult = store.restored(guildId);
|
|
let tmp11 = _createForOfIteratorHelperLoose;
|
|
let tmp12 = _createForOfIteratorHelperLoose(channels);
|
|
let iter3 = tmp12();
|
|
if (!iter3.done) {
|
|
do {
|
|
let value = iter3.value;
|
|
let _Object = Object;
|
|
let tmp13 = closure_24;
|
|
if (!Object.hasOwn(closure_24, value.id)) {
|
|
let tmp14 = setGuildChannel;
|
|
let tmp15 = callback6;
|
|
let tmp16 = setGuildChannel(callback6(value));
|
|
}
|
|
iter4 = tmp12();
|
|
iter3 = iter4;
|
|
let tmp17 = value;
|
|
} while (!iter4.done);
|
|
}
|
|
iter5 = tmp();
|
|
iter2 = iter5;
|
|
} while (!iter5.done);
|
|
}
|
|
return false;
|
|
},
|
|
LOAD_MESSAGES_AROUND_SUCCESS: handleLoadMessages,
|
|
LOAD_MESSAGES_SUCCESS: handleLoadMessages,
|
|
LOAD_THREADS_SUCCESS: handleLoadArchivedThreadsSuccess,
|
|
LOGOUT: function handleLogout() {
|
|
importDefaultResult.fileOnly("initializeClear()");
|
|
let closure_30 = {};
|
|
let closure_24 = {};
|
|
let closure_25 = {};
|
|
let closure_32 = {};
|
|
let closure_29 = {};
|
|
let closure_26 = {};
|
|
let closure_37 = {};
|
|
let closure_28 = {};
|
|
const set = new Set();
|
|
let closure_35 = {};
|
|
let closure_36 = Date.now();
|
|
},
|
|
OVERLAY_INITIALIZE: function handleInitialize(channels) {
|
|
let done;
|
|
const tmp = _createForOfIteratorHelperLoose(channels.channels);
|
|
let iter = tmp();
|
|
if (!iter.done) {
|
|
do {
|
|
let tmp2 = setChannel;
|
|
let tmp3 = require;
|
|
let tmp4 = dependencyMap;
|
|
let obj = require(1904) /* _createForOfIteratorHelperLoose */;
|
|
let tmp5 = callback6;
|
|
let tmp6 = setChannel(obj.deserializeChannel(callback6(iter.value)));
|
|
let iter2 = tmp();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
},
|
|
SEARCH_MESSAGES_SUCCESS: handleSearchMessagesSuccess,
|
|
MOD_VIEW_SEARCH_MESSAGES_SUCCESS: handleSearchMessagesSuccess,
|
|
THREAD_CREATE: handleThreadCreateOrUpdate,
|
|
THREAD_DELETE: handleDeleteChannel,
|
|
THREAD_LIST_SYNC: function handleThreadListSync(threads) {
|
|
threads = threads.threads;
|
|
const item = threads.forEach((type) => {
|
|
if (outer1_16.has(type.type)) {
|
|
outer1_49(type);
|
|
}
|
|
});
|
|
},
|
|
THREAD_UPDATE: handleThreadCreateOrUpdate
|
|
});
|
|
let result = set.fileFinishedImporting("stores/ChannelStore.tsx");
|
|
|
|
export default tmp7;
|
|
export const ChannelLoader = (() => {
|
|
class ChannelLoader {
|
|
constructor() {
|
|
tmp = outer1_8(this, ChannelLoader);
|
|
return;
|
|
}
|
|
}
|
|
let obj = {
|
|
key: "loadAllMissingChannels",
|
|
value() {
|
|
const guildIds = outer1_19.getGuildIds();
|
|
return this.loadGuildIds(guildIds.filter((arg0) => !outer2_34.has(arg0)));
|
|
}
|
|
};
|
|
let items = [obj, , ];
|
|
obj = {
|
|
key: "loadGuildFromChannelId",
|
|
value(arg0) {
|
|
let guildIds = null;
|
|
if (null != arg0) {
|
|
let guild_id;
|
|
const tmp5 = outer1_47(arg0);
|
|
if (null != tmp5) {
|
|
guild_id = tmp5.guild_id;
|
|
}
|
|
const items = [guild_id];
|
|
guildIds = ChannelLoader.loadGuildIds(items);
|
|
}
|
|
return guildIds;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "loadGuildIds",
|
|
value(arr) {
|
|
let found = arr.filter(ChannelLoader(outer1_2[15]).isNotNullish);
|
|
if (0 === found.length) {
|
|
return null;
|
|
} else {
|
|
const databaseResult = outer1_1(outer1_2[16]).database();
|
|
let closure_1 = databaseResult;
|
|
if (null == databaseResult) {
|
|
return null;
|
|
} else if (found.some((arg0) => !outer2_34.has(arg0))) {
|
|
let closure_2 = outer1_36;
|
|
return ChannelLoader(outer1_2[17]).tryLoadOrResetCacheGatewayAsync("loadChannels", outer1_7(async () => {
|
|
const mapped = outer1_0.map((guildId) => {
|
|
let closure_0 = guildId;
|
|
if (outer4_34.has(guildId)) {
|
|
return null;
|
|
} else if (null != outer4_35[guildId]) {
|
|
const _HermesInternal = HermesInternal;
|
|
outer4_22.fileOnly("Skipping loading " + guildId + " because a load is pending");
|
|
return null;
|
|
} else {
|
|
let obj = outer4_1(outer4_2[18]);
|
|
const async = obj.getAsync(outer2_1, guildId);
|
|
const nextPromise = async.then((channels) => {
|
|
outer5_22.fileOnly("Lazy loaded channels for " + closure_0 + " #:" + channels.length);
|
|
return { guildId: closure_0, channels };
|
|
});
|
|
outer4_35[guildId] = nextPromise;
|
|
obj = { guildId, promise: nextPromise };
|
|
return obj;
|
|
}
|
|
});
|
|
const found = mapped.filter(ChannelLoader(outer3_2[15]).isNotNullish);
|
|
const tmp = yield Promise.all(found.map((promise) => promise.promise));
|
|
if (outer3_36 !== outer1_2) {
|
|
outer3_22.fileOnly(`lastResetTime has changed, skipping loads for ${arr3.map((guildId) => guildId.guildId)}`);
|
|
return null;
|
|
} else {
|
|
const found1 = arr4.filter((guildId) => !outer4_34.has(guildId.guildId));
|
|
let obj = outer3_1(outer3_2[19]);
|
|
obj = { type: "LOAD_CHANNELS", channels: found1 };
|
|
yield obj.dispatch(obj);
|
|
return null;
|
|
}
|
|
arr3 = found;
|
|
arr4 = tmp;
|
|
}));
|
|
} else {
|
|
return null;
|
|
}
|
|
const obj2 = outer1_1(outer1_2[16]);
|
|
}
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
return callback3(ChannelLoader, null, items);
|
|
})();
|