1374 lines
46 KiB
TypeScript
1374 lines
46 KiB
TypeScript
// Module ID: 5057
|
|
// Function ID: 5058
|
|
// Name: MessageStore
|
|
// Dependencies: [32, 5, 2104, 5058, 2115, 502, 2051, 5584, 4470, 2111, 2073, 4472, 4482, 2102, 4657, 1378, 1086, 3, 11, 5585, 5590, 2077, 5588, 5059, 1391, 12, 7024, 5084, 4484, 7257, 13308, 504, 11120, 1985, 585, 2]
|
|
|
|
// Module 5057 (MessageStore)
|
|
import LoggerDefault from "Logger" /* 3 */;
|
|
import SnowflakeUtilsDefault from "SnowflakeUtils" /* 11 */;
|
|
import _modDef12 from "module_12" /* 12 */;
|
|
import get_initializedDefault from "get initialized" /* 504 */;
|
|
import DispatcherDefault from "Dispatcher" /* 585 */;
|
|
import FlagUtils from "FlagUtils" /* 1391 */;
|
|
import Server from "Server" /* 1985 */;
|
|
import DatabaseDaosDefault from "DatabaseDaos" /* 2077 */;
|
|
import ReactionUtils from "ReactionUtils" /* 4484 */;
|
|
import MessageRecordUtils from "MessageRecordUtils" /* 5059 */;
|
|
import ChannelMessagesDefault from "ChannelMessages" /* 5585 */;
|
|
import GatewayConnectionStore from "GatewayConnectionStore" /* 5590 */;
|
|
import ExplicitMediaRedactionUtils from "ExplicitMediaRedactionUtils" /* 7024 */;
|
|
import MessageQueue from "MessageQueue" /* 7257 */;
|
|
import canEditMessageDefault from "canEditMessage" /* 11120 */;
|
|
import GuildAutomodMessageStoreUtils from "GuildAutomodMessageStoreUtils" /* 13308 */;
|
|
import _slicedToArray from "_slicedToArray" /* 32 */;
|
|
import _asyncToGenerator from "_asyncToGenerator" /* 5 */;
|
|
import ImpersonateStore from "ImpersonateStore" /* 2104 */;
|
|
import EphemeralMessageStore from "EphemeralMessageStore" /* 5058 */;
|
|
import LocaleStore from "LocaleStore" /* 2115 */;
|
|
import AuthenticationStore from "AuthenticationStore" /* 502 */;
|
|
import ChannelStore from "ChannelStore" /* 2051 */;
|
|
import DimensionStore from "DimensionStore" /* 5584 */;
|
|
import GuildChannelStore from "GuildChannelStore" /* 4470 */;
|
|
import GuildMemberStore from "GuildMemberStore" /* 2111 */;
|
|
import GuildStore from "GuildStore" /* 2073 */;
|
|
import PermissionStore from "PermissionStore" /* 4472 */;
|
|
import RelationshipStore from "RelationshipStore" /* 4482 */;
|
|
import SelectedChannelStore from "SelectedChannelStore" /* 2102 */;
|
|
import SelectedGuildStore from "SelectedGuildStore" /* 4657 */;
|
|
import UserStore from "UserStore" /* 1378 */;
|
|
import Constants from "Constants" /* 1086 */;
|
|
import size from "module_2" /* 2 */;
|
|
|
|
let addReactionBatch, c6, c7, embeds, importDefault, interaction, set2, set3;
|
|
|
|
let closure_19;
|
|
let closure_20;
|
|
let closure_21;
|
|
let closure_22;
|
|
let closure_23;
|
|
let closure_24;
|
|
let closure_25;
|
|
let tmp3;
|
|
const IOSPushNotificationRawPayloadFixExperiment = tmp3(5588);
|
|
function reinjectEphemerals(channelId, truncateResult) {
|
|
let closure_0 = truncateResult;
|
|
if (truncateResult.hasMoreAfter) {
|
|
return truncateResult;
|
|
} else {
|
|
const messages = EphemeralMessageStore.getMessages(channelId);
|
|
if (0 === messages.length) {
|
|
return truncateResult;
|
|
} else {
|
|
let firstResult = null;
|
|
if (truncateResult.hasMoreBefore) {
|
|
firstResult = truncateResult.first();
|
|
}
|
|
importDefault = firstResult;
|
|
const found = messages.filter((id) => {
|
|
const hasItem = require.has(id.id);
|
|
let tmp2 = !hasItem;
|
|
if (tmp2) {
|
|
let tmp5 = null == importDefault;
|
|
if (!tmp5) {
|
|
obj = SnowflakeUtilsDefault;
|
|
tmp5 = obj.compare(id.id, tmp3.id) > 0;
|
|
}
|
|
tmp2 = tmp5;
|
|
}
|
|
return tmp2;
|
|
});
|
|
let mutation = truncateResult;
|
|
if (0 !== found.length) {
|
|
mutation = truncateResult.mutate((_merge) => {
|
|
_merge._merge(found);
|
|
const _array = _merge._array;
|
|
const sorted = _array.sort((id, id2) => {
|
|
obj = closure_1_1(found[18]);
|
|
return obj.compare(id.id, id2.id);
|
|
});
|
|
}, true);
|
|
}
|
|
return mutation;
|
|
}
|
|
}
|
|
}
|
|
function handleConnectionOpen() {
|
|
const arr = ChannelMessagesDefault;
|
|
const item = arr.forEach((mutate) => {
|
|
obj = ChannelMessagesDefault;
|
|
obj.commit(mutate.mutate({ ready: false, loadingMore: false }));
|
|
});
|
|
set.clear();
|
|
map.clear();
|
|
}
|
|
let obj = function _addPushNotificationMessageIfNotCached() {
|
|
obj = _asyncToGenerator(async (arg0, value, arg2) => {
|
|
let closure_3;
|
|
let messagesResult;
|
|
let closure_0 = arg0;
|
|
let closure_1 = value;
|
|
let closure_2 = arg2;
|
|
if (c7 === 2) {
|
|
c7 = 3;
|
|
throw new TypeError("Generator functions may not be called on executing generators");
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
const obj5 = { value, done: true };
|
|
return obj5;
|
|
} else {
|
|
return { value: "IconComponent", done: null };
|
|
}
|
|
} else {
|
|
let c5;
|
|
let tmp25;
|
|
try {
|
|
c7 = 2;
|
|
if (0 === c6) {
|
|
if (arg0 === 1) {
|
|
c7 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c7 = 3;
|
|
const obj6 = { value, done: true };
|
|
return obj6;
|
|
} else {
|
|
let closure_4 = tmp;
|
|
tmp25 = undefined;
|
|
const obj9 = DatabaseDaosDefault;
|
|
const databaseResult = obj9.database();
|
|
basicChannel = basicChannel.getBasicChannel(closure_0);
|
|
const tmp30 = closure_0;
|
|
const tmp31 = closure_1;
|
|
if (null != databaseResult) {
|
|
if (null != basicChannel) {
|
|
c5 = 1;
|
|
const obj4 = DatabaseDaosDefault;
|
|
c6 = 2;
|
|
c7 = 1;
|
|
const obj7 = { value: messagesResult.get(basicChannel.guild_id, tmp30, tmp31.id), done: false };
|
|
messagesResult = obj4.messages(databaseResult);
|
|
return obj7;
|
|
}
|
|
}
|
|
}
|
|
} else if (1 === tmp4) {
|
|
c5 = 0;
|
|
} else if (arg0 === 1) {
|
|
c7 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c5 = 0;
|
|
c7 = 3;
|
|
obj = { value, done: true };
|
|
return obj;
|
|
} else if (null != value) {
|
|
c5 = 0;
|
|
c7 = 3;
|
|
return { value: "IconComponent", done: null };
|
|
} else {
|
|
c5 = 0;
|
|
}
|
|
closure_132_28.log("Push notification message not in cache, adding directly", closure_1.id, closure_1.channel_id);
|
|
const obj2 = closure_132_1(closure_132_2[19]);
|
|
tmp25 = obj2.getOrCreate(closure_0);
|
|
const obj3 = closure_132_1(closure_132_2[19]);
|
|
obj3.commit(tmp25.receivePushNotification(closure_1, closure_2));
|
|
closure_132_35.emitChange();
|
|
c7 = 3;
|
|
return { value: "IconComponent", done: null };
|
|
} catch (tmp24) {
|
|
tmp25 = c5;
|
|
if (0 === c5) {
|
|
c7 = 3;
|
|
throw tmp24;
|
|
} else {
|
|
c6 = 1;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return obj(...arguments);
|
|
};
|
|
function receiveMediaMentionMessage(item10038) {
|
|
let guild_id;
|
|
let obj2;
|
|
const media_mention = item10038.media_mention;
|
|
let message_id;
|
|
if (media_mention != null) {
|
|
message_id = media_mention.message_id;
|
|
}
|
|
if (null != message_id) {
|
|
const attachment_id = item10038.media_mention.attachment_id;
|
|
const obj3 = ChannelMessagesDefault;
|
|
const orCreate = obj3.getOrCreate(attachment_id);
|
|
obj = { channel_id: attachment_id, type: constants6.MEDIA_MENTION_MESSAGE, id: item10038.media_mention.message_id, message_reference: obj2 };
|
|
const merged = Object.assign(item10038);
|
|
obj2 = { channel_id: item10038.channel_id, message_id: item10038.media_mention.message_id, type: constants4.DEFAULT, guild_id };
|
|
const channel = ChannelStore.getChannel(item10038.channel_id);
|
|
guild_id = undefined;
|
|
const tmp5 = importDefault;
|
|
if (channel != null) {
|
|
guild_id = channel.guild_id;
|
|
}
|
|
const receiveMessageResult = orCreate.receiveMessage(obj, false);
|
|
const mutation = receiveMessageResult.mutate({ ready: true });
|
|
const tmp5Result = tmp5(5585);
|
|
tmp5Result.commit(mutation);
|
|
}
|
|
}
|
|
function invalidateInaccessibleMessages(arg0) {
|
|
let c1;
|
|
let closure_0 = arg0;
|
|
importDefault = false;
|
|
const arr = ChannelMessagesDefault;
|
|
const item = arr.forEach((cached) => {
|
|
if (!cached.cached) {
|
|
const basicChannel = ChannelStore.getBasicChannel(cached.channelId);
|
|
let guild_id;
|
|
if (basicChannel != null) {
|
|
guild_id = basicChannel.guild_id;
|
|
}
|
|
if (guild_id === guildId) {
|
|
if (!PermissionStore.canBasicChannel(constants.VIEW_CHANNEL, basicChannel)) {
|
|
obj = ChannelMessagesDefault;
|
|
obj.commit(cached.mutate({ cached: true }));
|
|
c1 = true;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return importDefault;
|
|
}
|
|
function handleRoleUpdate(guildId) {
|
|
let c1;
|
|
guildId = guildId.guildId;
|
|
importDefault = false;
|
|
const arr = ChannelMessagesDefault;
|
|
const item = arr.forEach((cached) => {
|
|
if (!cached.cached) {
|
|
const basicChannel = ChannelStore.getBasicChannel(cached.channelId);
|
|
let guild_id;
|
|
if (basicChannel != null) {
|
|
guild_id = basicChannel.guild_id;
|
|
}
|
|
if (guild_id === guildId) {
|
|
if (!PermissionStore.canBasicChannel(constants.VIEW_CHANNEL, basicChannel)) {
|
|
obj = ChannelMessagesDefault;
|
|
obj.commit(cached.mutate({ cached: true }));
|
|
c1 = true;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return importDefault;
|
|
}
|
|
function handleCleanup() {
|
|
let channel;
|
|
const arr = ChannelMessagesDefault;
|
|
const item = arr.forEach((channelId) => {
|
|
channelId = channelId.channelId;
|
|
if (null == channel.getChannel(channelId)) {
|
|
obj = ChannelMessagesDefault;
|
|
obj.clear(channelId);
|
|
}
|
|
});
|
|
}
|
|
function handleRelationshipUpdate() {
|
|
let blockedForMessage;
|
|
let c0 = false;
|
|
const arr = ChannelMessagesDefault;
|
|
const item = arr.forEach((reset) => {
|
|
obj = ChannelMessagesDefault;
|
|
obj.commit(reset.reset(reset.map((blocked) => {
|
|
let result = blocked;
|
|
if (blocked.blocked !== blockedForMessage.isBlockedForMessage(blocked)) {
|
|
c0 = true;
|
|
result = blocked.set("blocked", obj.isBlockedForMessage(blocked));
|
|
}
|
|
let result1 = result;
|
|
if (result.ignored !== blockedForMessage.isIgnoredForMessage(result)) {
|
|
c0 = true;
|
|
result1 = result.set("ignored", obj.isIgnoredForMessage(result));
|
|
}
|
|
return result1;
|
|
})));
|
|
});
|
|
return c0;
|
|
}
|
|
function performAuthorUpdate(guildId) {
|
|
let closure_0 = guildId;
|
|
const arr = ChannelMessagesDefault;
|
|
const item = arr.forEach((channelId) => {
|
|
const channel = ChannelStore.getChannel(channelId.channelId);
|
|
let guild_id;
|
|
if (channel != null) {
|
|
guild_id = channel.guild_id;
|
|
}
|
|
if (guild_id === guildId) {
|
|
const items = [];
|
|
let c1 = false;
|
|
const item = channelId.forEach((nick) => {
|
|
let colorString;
|
|
obj = guildId(closure_2_2[27]);
|
|
const messageAuthor = obj.getMessageAuthor(nick);
|
|
({ nick, colorString } = messageAuthor);
|
|
if (nick === nick.nick) {
|
|
if (colorString === nick.colorString) {
|
|
items.push(nick);
|
|
}
|
|
}
|
|
c1 = true;
|
|
items.push(nick.merge({ nick, colorString }));
|
|
});
|
|
const tmp4 = c1;
|
|
if (tmp4) {
|
|
obj = ChannelMessagesDefault;
|
|
obj.commit(channelId.reset(items));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function handleReaction(optimistic) {
|
|
let channelId;
|
|
let closure_129_1;
|
|
let closure_129_2;
|
|
let closure_129_3;
|
|
let messageId;
|
|
let userId;
|
|
let closure_0 = optimistic;
|
|
({ type: closure_129_1, channelId, emoji: closure_129_2, reactionType: closure_129_3 } = optimistic);
|
|
({ messageId, userId } = optimistic);
|
|
obj = ChannelMessagesDefault;
|
|
const value = obj.get(channelId);
|
|
if (null == value) {
|
|
return false;
|
|
} else {
|
|
const obj4 = ReactionUtils;
|
|
if (obj4.shouldApplyReaction(optimistic)) {
|
|
const basicChannel = ChannelStore.getBasicChannel(channelId);
|
|
let type;
|
|
if (basicChannel != null) {
|
|
type = basicChannel.type;
|
|
}
|
|
let closure_4 = type === constants2.DM;
|
|
let closure_5 = AuthenticationStore.getId() === userId;
|
|
const updateResult = value.update(messageId, (addReaction) => {
|
|
let addReactionResult;
|
|
if ("MESSAGE_REACTION_ADD" === closure_1_1) {
|
|
obj = { colors: colors.colors, reactionType, isDMChannel };
|
|
addReactionResult = addReaction.addReaction(closure_1_2, closure_5, obj);
|
|
} else {
|
|
addReactionResult = addReaction.removeReaction(closure_1_2, closure_5, reactionType);
|
|
}
|
|
return addReactionResult;
|
|
});
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(updateResult);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function handleMessageSendFailedAutomod(arg0) {
|
|
let messageData;
|
|
({ type: require, messageData } = arg0);
|
|
const message = messageData.message;
|
|
obj = MessageQueue;
|
|
const failedMessageId = obj.getFailedMessageId(messageData);
|
|
const channelId = message.channelId;
|
|
const obj2 = ChannelMessagesDefault;
|
|
const orCreate = obj2.getOrCreate(channelId);
|
|
if (orCreate.has(failedMessageId)) {
|
|
const updateResult = orCreate.update(failedMessageId, (embeds) => {
|
|
embeds = embeds.embeds;
|
|
let length;
|
|
if (embeds != null) {
|
|
length = embeds.filter(GuildAutomodMessageStoreUtils.isNotAutomodEmbed).length;
|
|
}
|
|
let result = embeds;
|
|
if (length > 0) {
|
|
result = embeds.set("embeds", []);
|
|
}
|
|
let result1 = result;
|
|
if ("MESSAGE_SEND_FAILED_AUTOMOD" === require) {
|
|
set = result.set;
|
|
obj = FlagUtils;
|
|
result1 = set("flags", obj.addFlag(result.flags, constants.EPHEMERAL));
|
|
}
|
|
return result1;
|
|
});
|
|
const tmp3Result = ChannelMessagesDefault;
|
|
tmp3Result.commit(updateResult);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
({ BasicPermissions: closure_19, ChannelTypes: closure_20, MessageFlags: closure_21, MessageReferenceTypes: closure_22, MessageStates: closure_23, MessageTypes: closure_24, Permissions: closure_25 } = Constants);
|
|
let set = new Set();
|
|
const map = new Map();
|
|
let tmp5 = new LoggerDefault("MessageStore");
|
|
const logger = tmp5;
|
|
let c29 = false;
|
|
const Store = get_initializedDefault.Store;
|
|
class MessageStore extends Store {
|
|
initialize() {
|
|
this.waitFor(AuthenticationStore, ChannelStore, DimensionStore, EphemeralMessageStore, GuildChannelStore, GuildMemberStore, GuildStore, ImpersonateStore, LocaleStore, PermissionStore, RelationshipStore, SelectedChannelStore, SelectedGuildStore, UserStore);
|
|
const items = [ImpersonateStore];
|
|
this.syncWith(items, () => {
|
|
|
|
});
|
|
}
|
|
getMessages(arg0) {
|
|
obj = ImpersonateStore;
|
|
if (ImpersonateStore.hasViewingRoles()) {
|
|
const channel = ChannelStore.getChannel(arg0);
|
|
let guildId;
|
|
if (channel != null) {
|
|
guildId = channel.getGuildId();
|
|
}
|
|
if (obj.isViewingRoles(guildId)) {
|
|
if (!PermissionStore.can(constants7.VIEW_CHANNEL, channel)) {
|
|
const self = this;
|
|
const self2 = this;
|
|
const tmp9 = new ChannelMessagesDefault(arg0);
|
|
return tmp9;
|
|
}
|
|
}
|
|
}
|
|
const obj3 = ChannelMessagesDefault;
|
|
return obj3.getOrCreate(arg0);
|
|
}
|
|
getMessage(arg0, arg1) {
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(arg0);
|
|
return orCreate.get(arg1);
|
|
}
|
|
getAutomodRemovalNotice(id) {
|
|
return map.get(id);
|
|
}
|
|
getLastEditableMessage(id) {
|
|
id = UserStore.getCurrentUser();
|
|
let tmp = _modDef12;
|
|
const messages = this.getMessages(id);
|
|
const tmpResult = tmp(messages.toArray());
|
|
const reversed = tmpResult.reverse();
|
|
return reversed.find((item) => {
|
|
id = undefined;
|
|
const tmp = canEditMessageDefault;
|
|
if (id != null) {
|
|
id = id.id;
|
|
}
|
|
return tmp(item, id);
|
|
});
|
|
}
|
|
getLastChatCommandMessage(arg0) {
|
|
let id = UserStore.getCurrentUser();
|
|
const messages = this.getMessages(arg0);
|
|
const toArrayResult = messages.toArray();
|
|
const reversed = toArrayResult.reverse();
|
|
return reversed.find((interaction) => {
|
|
interaction = interaction.interaction;
|
|
let type;
|
|
if (interaction != null) {
|
|
type = interaction.type;
|
|
}
|
|
let tmp4 = type === Server.InteractionTypes.APPLICATION_COMMAND;
|
|
if (tmp4) {
|
|
const interactionData = interaction.interactionData;
|
|
let type1;
|
|
if (interactionData != null) {
|
|
type1 = interactionData.type;
|
|
}
|
|
tmp4 = type1 === Server.ApplicationCommandType.CHAT;
|
|
}
|
|
if (tmp4) {
|
|
let id1;
|
|
id = interaction.interaction.user.id;
|
|
if (id != null) {
|
|
id1 = id.id;
|
|
}
|
|
tmp4 = id === id1;
|
|
}
|
|
return tmp4;
|
|
});
|
|
}
|
|
getLastMessage(channelId) {
|
|
const tmp = _modDef12;
|
|
const messages = this.getMessages(channelId);
|
|
const tmpResult = tmp(messages.toArray());
|
|
const reversed = tmpResult.reverse();
|
|
return reversed.get(0);
|
|
}
|
|
getLastNonCurrentUserMessage(arg0) {
|
|
const currentUser = UserStore.getCurrentUser();
|
|
const tmp = _modDef12;
|
|
const messages = this.getMessages(arg0);
|
|
const tmpResult = tmp(messages.toArray());
|
|
const reversed = tmpResult.reverse();
|
|
return reversed.find((author) => {
|
|
let id1;
|
|
id = author.author.id;
|
|
if (id != null) {
|
|
id1 = id.id;
|
|
}
|
|
return id !== id1;
|
|
});
|
|
}
|
|
jumpedMessageId(arg0) {
|
|
obj = ChannelMessagesDefault;
|
|
const value = obj.get(arg0);
|
|
let jumpTargetId;
|
|
if (value != null) {
|
|
jumpTargetId = value.jumpTargetId;
|
|
}
|
|
return jumpTargetId;
|
|
}
|
|
focusedMessageId(arg0) {
|
|
obj = ChannelMessagesDefault;
|
|
const value = obj.get(arg0);
|
|
let focusTargetId;
|
|
if (value != null) {
|
|
focusTargetId = value.focusTargetId;
|
|
}
|
|
return focusTargetId;
|
|
}
|
|
hasPresent(arg0) {
|
|
obj = ChannelMessagesDefault;
|
|
const value = obj.get(arg0);
|
|
const tmp = null != value && value.ready && value.hasPresent();
|
|
return tmp;
|
|
}
|
|
isReady(arg0) {
|
|
obj = ChannelMessagesDefault;
|
|
return obj.getOrCreate(arg0).ready;
|
|
}
|
|
whenReady(arg0, arg1) {
|
|
const self = this;
|
|
let closure_1 = arg0;
|
|
let closure_0 = arg1;
|
|
const result = this.addConditionalChangeListener(() => {
|
|
if (self.isReady(closure_1)) {
|
|
const _setImmediate = setImmediate;
|
|
setImmediate(closure_0);
|
|
return false;
|
|
}
|
|
});
|
|
}
|
|
isLoadingMessages(channelId) {
|
|
obj = ChannelMessagesDefault;
|
|
return obj.getOrCreate(channelId).loadingMore;
|
|
}
|
|
hasCurrentUserSentMessage(arg0) {
|
|
const currentUser = UserStore.getCurrentUser();
|
|
const messages = this.getMessages(arg0);
|
|
return null != messages.findNewest((author) => {
|
|
let id1;
|
|
id = author.author.id;
|
|
if (id != null) {
|
|
id1 = id.id;
|
|
}
|
|
return id === id1;
|
|
});
|
|
}
|
|
hasCurrentUserSentWaveBlockingMessage(id) {
|
|
id = UserStore.getCurrentUser();
|
|
const messages = this.getMessages(id);
|
|
return null != messages.findNewest((type) => {
|
|
let tmp = type.type !== constants.FRIEND_REQUEST_ACCEPTED;
|
|
if (tmp) {
|
|
let id1;
|
|
id = type.author.id;
|
|
if (id != null) {
|
|
id1 = id.id;
|
|
}
|
|
tmp = id === id1;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
hasCurrentUserSentMessageSinceAppStart() {
|
|
return c29;
|
|
}
|
|
}
|
|
const prototype = MessageStore.prototype;
|
|
MessageStore.displayName = "MessageStore";
|
|
obj = {
|
|
BACKGROUND_SYNC_CHANNEL_MESSAGES: function handleBackgroundSyncChannelMessages(changesByChannelId) {
|
|
changesByChannelId = changesByChannelId.changesByChannelId;
|
|
for (const key10012 in changesByChannelId) {
|
|
let tmp8 = key10012;
|
|
obj = ChannelMessagesDefault;
|
|
let value = obj.get(key10012);
|
|
if (null == value) {
|
|
continue;
|
|
} else {
|
|
let _default = GatewayConnectionStore.default;
|
|
let isConnectedResult = _default.isConnected();
|
|
if (!value.cached) {
|
|
if (isConnectedResult) {
|
|
let _HermesInternal = HermesInternal;
|
|
let str = "Skipping background message sync for ";
|
|
let str2 = " cached:";
|
|
let str3 = " ready:";
|
|
let str4 = " hasMoreAfter:";
|
|
let str5 = " isConnected:";
|
|
let logResult = logger.log("Skipping background message sync for " + tmp8 + " cached:" + value.cached + " ready:" + value.ready + " hasMoreAfter:" + value.hasMoreAfter + " isConnected:" + isConnectedResult);
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
let mergeDeltaResult = value.mergeDelta(changesByChannelId[key10012].new_messages, changesByChannelId[key10012].modified_messages, changesByChannelId[key10012].deleted_message_ids);
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
},
|
|
CONNECTION_OPEN: handleConnectionOpen,
|
|
OVERLAY_INITIALIZE: handleConnectionOpen,
|
|
CACHE_LOADED: function handleCacheLoaded(messages) {
|
|
let tmp6;
|
|
let tmp7;
|
|
obj = SnowflakeUtilsDefault;
|
|
const entries = obj.entries(messages.messages);
|
|
const tmp2 = entries[Symbol.iterator]();
|
|
while (tmp2 !== undefined) {
|
|
let tmp5 = _slicedToArray(tmp3, 2);
|
|
[tmp6, tmp7] = tmp5;
|
|
let obj2 = ChannelMessagesDefault;
|
|
let orCreate = obj2.getOrCreate(tmp6);
|
|
let addCachedMessagesResult = orCreate.addCachedMessages(tmp7, true);
|
|
let obj4 = ChannelMessagesDefault;
|
|
let commitResult = obj4.commit(addCachedMessagesResult);
|
|
continue;
|
|
}
|
|
},
|
|
LOAD_MESSAGES: function handleLoadMessages() {
|
|
return true;
|
|
},
|
|
LOAD_MESSAGES_SUCCESS: function handleLoadMessagesSuccess(arg0) {
|
|
let avoidInitialScroll;
|
|
let channelId;
|
|
let hasMoreAfter;
|
|
let hasMoreBefore;
|
|
let isAfter;
|
|
let isBefore;
|
|
let isStale;
|
|
let jump;
|
|
let messages;
|
|
let requestStartTime;
|
|
let truncate;
|
|
({ channelId, isBefore, isAfter, messages } = arg0);
|
|
({ jump, hasMoreBefore, hasMoreAfter, isStale, truncate, avoidInitialScroll, requestStartTime } = arg0);
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
const complete = orCreate.loadComplete({ newMessages: messages, isBefore, isAfter, jump, hasMoreBefore, hasMoreAfter, cached: isStale, hasFetched: true, avoidInitialScroll, requestStartTime });
|
|
let tmp3 = null == truncate;
|
|
if (!tmp3) {
|
|
tmp3 = !isBefore && !isAfter;
|
|
}
|
|
if (!tmp3) {
|
|
tmp3 = isBefore && isAfter;
|
|
}
|
|
let truncateResult = complete;
|
|
if (!tmp3) {
|
|
truncateResult = complete.truncate(isBefore, isAfter);
|
|
}
|
|
const tmp7 = reinjectEphemerals(channelId, truncateResult);
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(tmp7);
|
|
for (const item10038 of messages) {
|
|
let tmp10 = receiveMediaMentionMessage(item10038);
|
|
continue;
|
|
}
|
|
},
|
|
LOAD_MESSAGES_FAILURE: function handleLoadMessagesFailure(channelId) {
|
|
channelId = channelId.channelId;
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
const obj3 = ChannelMessagesDefault;
|
|
obj3.commit(orCreate.mutate({ loadingMore: false, error: true }));
|
|
},
|
|
LOAD_MESSAGES_SUCCESS_CACHED: function handleLoadMessagesSuccessCached(truncate) {
|
|
let after;
|
|
let before;
|
|
let channelId;
|
|
let focus;
|
|
let found;
|
|
let jump;
|
|
let jumpToPresentResult;
|
|
let limit;
|
|
({ channelId, jump, focus, before, after, limit } = truncate);
|
|
truncate = truncate.truncate;
|
|
let tmp2 = found;
|
|
obj = require("ChannelMessages");
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
let present;
|
|
const tmp = importDefault;
|
|
if (jump != null) {
|
|
present = jump.present;
|
|
}
|
|
if (present) {
|
|
jumpToPresentResult = orCreate.jumpToPresent(limit);
|
|
} else {
|
|
let messageId;
|
|
if (focus != null) {
|
|
messageId = focus.messageId;
|
|
}
|
|
if (null != messageId) {
|
|
jumpToPresentResult = orCreate.focusOnMessage(focus.messageId);
|
|
} else {
|
|
let messageId1;
|
|
if (jump != null) {
|
|
messageId1 = jump.messageId;
|
|
}
|
|
if (null != messageId1) {
|
|
const obj2 = { messageId: null, flash: null, offset: null, returnTargetId: null, jumpType: null, onJumpComplete: null };
|
|
({ messageId: obj4.messageId, flash: obj4.flash, offset: obj4.offset, returnMessageId: obj4.returnTargetId, jumpType: obj4.jumpType, onJumpComplete: obj4.onJumpComplete } = jump);
|
|
jumpToPresentResult = orCreate.jumpToMessage(obj2);
|
|
} else {
|
|
jumpToPresentResult = orCreate;
|
|
const tmp6 = null == before && null == after;
|
|
if (!tmp6) {
|
|
jumpToPresentResult = orCreate.loadFromCache(null != before, limit);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let tmp7 = null == truncate;
|
|
if (!tmp7) {
|
|
tmp7 = null == before && null == after;
|
|
}
|
|
if (!tmp7) {
|
|
tmp7 = null != before && null != after;
|
|
}
|
|
let truncateResult = jumpToPresentResult;
|
|
if (!tmp7) {
|
|
truncateResult = jumpToPresentResult.truncate(null != before, null != after);
|
|
}
|
|
require = truncateResult;
|
|
let tmp10 = truncateResult;
|
|
if (!truncateResult.hasMoreAfter) {
|
|
const messages = EphemeralMessageStore.getMessages(channelId);
|
|
tmp10 = truncateResult;
|
|
if (0 !== messages.length) {
|
|
let firstResult = null;
|
|
if (truncateResult.hasMoreBefore) {
|
|
firstResult = truncateResult.first();
|
|
}
|
|
importDefault = firstResult;
|
|
found = messages.filter((id) => {
|
|
const hasItem = require.has(id.id);
|
|
let tmp2 = !hasItem;
|
|
if (tmp2) {
|
|
let tmp5 = null == importDefault;
|
|
if (!tmp5) {
|
|
obj = SnowflakeUtilsDefault;
|
|
tmp5 = obj.compare(id.id, tmp3.id) > 0;
|
|
}
|
|
tmp2 = tmp5;
|
|
}
|
|
return tmp2;
|
|
});
|
|
let mutation = truncateResult;
|
|
if (0 !== found.length) {
|
|
mutation = truncateResult.mutate((_merge) => {
|
|
_merge._merge(found);
|
|
const _array = _merge._array;
|
|
const sorted = _array.sort((id, id2) => {
|
|
obj = closure_1_1(found[18]);
|
|
return obj.compare(id.id, id2.id);
|
|
});
|
|
}, true);
|
|
}
|
|
tmp10 = mutation;
|
|
}
|
|
}
|
|
const tmpResult = tmp(tmp2[19]);
|
|
tmpResult.commit(tmp10);
|
|
},
|
|
LOCAL_MESSAGES_LOADED: function handleLocalMessagesLoaded(channelId) {
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channelId.channelId);
|
|
const addCachedMessagesResult = orCreate.addCachedMessages(channelId.messages, channelId.stale);
|
|
const isForegroundCacheLoad = channelId.isForegroundCacheLoad && channelId.messages.length > 0 && null == addCachedMessagesResult.jumpTargetId;
|
|
let mutation = addCachedMessagesResult;
|
|
if (isForegroundCacheLoad) {
|
|
const obj2 = { initialScrollSequenceId: addCachedMessagesResult.initialScrollSequenceId + 1, suppressRowAnimationSequenceId: addCachedMessagesResult.suppressRowAnimationSequenceId + 1 };
|
|
mutation = addCachedMessagesResult.mutate(obj2);
|
|
}
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(mutation);
|
|
},
|
|
LOAD_MESSAGE_INTERACTION_DATA_SUCCESS: function handleLoadMessageInteractionDataSuccess(messageId) {
|
|
let closure_0 = messageId;
|
|
messageId = messageId.messageId;
|
|
const channelId = messageId.channelId;
|
|
obj = ChannelMessagesDefault;
|
|
const value = obj.get(channelId);
|
|
if (null != value) {
|
|
if (value.has(messageId)) {
|
|
const updateResult = value.update(messageId, (set) => set.set("interactionData", interactionData.interactionData));
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(updateResult);
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
TRUNCATE_MESSAGES: function handleTruncateMessages(arg0) {
|
|
let channelId;
|
|
let truncateBottom;
|
|
let truncateTop;
|
|
({ channelId, truncateBottom, truncateTop } = arg0);
|
|
logger.log("Truncating messages for " + channelId + " bottom:" + truncateBottom + " top:" + truncateTop);
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
const truncateResult = orCreate.truncate(truncateBottom, truncateTop);
|
|
const obj3 = ChannelMessagesDefault;
|
|
obj3.commit(truncateResult);
|
|
},
|
|
CLEAR_MESSAGES: function handleClearMessages(channelId) {
|
|
channelId = channelId.channelId;
|
|
logger.log("Clearing messages for " + channelId);
|
|
obj = ChannelMessagesDefault;
|
|
obj.clear(channelId);
|
|
set.clear();
|
|
},
|
|
MESSAGE_CREATE: function handleIncomingMessage(isPushNotification) {
|
|
let channelId;
|
|
let message;
|
|
let optimistic;
|
|
let ready;
|
|
function addPushNotificationMessageIfNotCached() {
|
|
return obj(...arguments);
|
|
}
|
|
({ channelId, message, optimistic } = isPushNotification);
|
|
isPushNotification = isPushNotification.isPushNotification;
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
const _default = GatewayConnectionStore.default;
|
|
const isConnectedResult = _default.isConnected();
|
|
if (isPushNotification) {
|
|
const tmp3Result = IOSPushNotificationRawPayloadFixExperiment;
|
|
if (tmp3Result.isIOSPushNotificationRawPayloadFixExperimentEnabled()) {
|
|
addPushNotificationMessageIfNotCached(channelId, message, isConnectedResult);
|
|
} else {
|
|
logger.log("Inserting message tapped on from a push notification", message.id, message.channel_id);
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(orCreate.receivePushNotification(message, isConnectedResult));
|
|
}
|
|
ready = flag2;
|
|
} else {
|
|
ready = orCreate.ready;
|
|
if (ready) {
|
|
let tmp6 = !optimistic;
|
|
if (optimistic) {
|
|
tmp6 = !orCreate.has(message.id);
|
|
}
|
|
if (tmp6) {
|
|
const hasItem = null != message.nonce && message.state !== constants5.SENDING && set.has(message.nonce);
|
|
let removeResult = orCreate;
|
|
if (hasItem) {
|
|
removeResult = orCreate.remove(message.nonce);
|
|
set.delete(message.nonce);
|
|
}
|
|
const receiveMessageResult = removeResult.receiveMessage(message, true === DimensionStore.isAtBottom(channelId));
|
|
const tmpResult2 = ChannelMessagesDefault;
|
|
tmpResult2.commit(receiveMessageResult);
|
|
receiveMediaMentionMessage(message);
|
|
}
|
|
ready = tmp6;
|
|
}
|
|
}
|
|
return ready;
|
|
},
|
|
MESSAGE_SEND_FAILED: function handleSendFailed(channelId) {
|
|
let messageId;
|
|
({ messageId, reason: require } = channelId);
|
|
channelId = channelId.channelId;
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
if (null != orCreate) {
|
|
if (orCreate.has(messageId)) {
|
|
let removeResult;
|
|
const value = orCreate.get(messageId, true);
|
|
let isPollResult;
|
|
if (value != null) {
|
|
isPollResult = value.isPoll();
|
|
}
|
|
if (true === isPollResult) {
|
|
removeResult = orCreate.remove(messageId);
|
|
} else {
|
|
removeResult = orCreate.update(messageId, (set) => {
|
|
let set3Result;
|
|
const result = set.set("state", constants2.SEND_FAILED);
|
|
if (result.isCommandType()) {
|
|
let str3 = require;
|
|
set2 = result.set;
|
|
if (require == null) {
|
|
str3 = "";
|
|
}
|
|
const set2Result = set2("interactionError", str3);
|
|
set3 = set2Result.set;
|
|
const obj2 = FlagUtils;
|
|
set3Result = set3("flags", obj2.addFlag(set2Result.flags, constants.EPHEMERAL));
|
|
} else {
|
|
let str = require;
|
|
set3Result = result;
|
|
if (null != require) {
|
|
set = result.set;
|
|
if (str == null) {
|
|
str = "";
|
|
}
|
|
set3Result = set("interactionError", str);
|
|
}
|
|
}
|
|
return set3Result;
|
|
});
|
|
}
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(removeResult);
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
MESSAGE_SEND_FAILED_AUTOMOD: handleMessageSendFailedAutomod,
|
|
AUTO_MODERATION_CONTENT_DELETED: function handleAutomodContentDeleted(message) {
|
|
message = message.message;
|
|
if (null != message) {
|
|
if (null == message.thread) {
|
|
const channel_id = message.channel_id;
|
|
const obj4 = ChannelMessagesDefault;
|
|
const orCreate = obj4.getOrCreate(channel_id);
|
|
let ready = orCreate.ready;
|
|
const tmp11 = importDefault;
|
|
if (ready) {
|
|
const hasItem = orCreate.has(message.id);
|
|
let tmp3 = !hasItem;
|
|
obj = orCreate;
|
|
if (!hasItem) {
|
|
const receiveMessageResult = orCreate.receiveMessage(message, true === DimensionStore.isAtBottom(channel_id));
|
|
tmp3 = !receiveMessageResult.has(message.id);
|
|
obj = receiveMessageResult;
|
|
}
|
|
if (!tmp3) {
|
|
const updateResult = obj.update(message.id, (set) => {
|
|
set = set.set;
|
|
obj = FlagUtils;
|
|
return set("flags", obj.addFlag(set.flags, constants.EPHEMERAL));
|
|
});
|
|
const tmp11Result = tmp11(5585);
|
|
tmp11Result.commit(updateResult);
|
|
const result = map.set(message.id, tmp);
|
|
}
|
|
ready = tmp5;
|
|
}
|
|
return ready;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
MESSAGE_EDIT_FAILED_AUTOMOD: handleMessageSendFailedAutomod,
|
|
MESSAGE_UPDATE: function handleMessageUpdate(message) {
|
|
const id = message.message.id;
|
|
const channel_id = message.message.channel_id;
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channel_id);
|
|
if (null != orCreate) {
|
|
if (orCreate.has(id)) {
|
|
const updateResult = orCreate.update(id, (message) => {
|
|
obj = MessageRecordUtils;
|
|
return obj.updateMessageRecord(message, message.message);
|
|
});
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(updateResult);
|
|
message = message.message;
|
|
const media_mention = message.media_mention;
|
|
let message_id;
|
|
if (media_mention != null) {
|
|
message_id = media_mention.message_id;
|
|
}
|
|
if (null != message_id) {
|
|
if ("content" in message) {
|
|
const attachment_id = message.media_mention.attachment_id;
|
|
const tmpResult3 = ChannelMessagesDefault;
|
|
const orCreate1 = tmpResult3.getOrCreate(attachment_id);
|
|
const updateResult1 = orCreate1.update(message.media_mention.message_id, (message) => {
|
|
obj = message(dependencyMap[23]);
|
|
const obj2 = { content: message.content };
|
|
return obj.updateMessageRecord(message, obj2);
|
|
});
|
|
const tmpResult4 = ChannelMessagesDefault;
|
|
tmpResult4.commit(updateResult1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
MESSAGE_EXPLICIT_CONTENT_SCAN_TIMEOUT: function handleMessageExplicitContentScanTimeout(messageId) {
|
|
messageId = messageId.messageId;
|
|
const channelId = messageId.channelId;
|
|
obj = ChannelMessagesDefault;
|
|
const value = obj.get(channelId);
|
|
if (null != value) {
|
|
if (value.has(messageId)) {
|
|
const updateResult = value.update(messageId, ExplicitMediaRedactionUtils.handleExplicitMediaScanTimeoutForMessage);
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(updateResult);
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
MESSAGE_DELETE: function handleMessageDelete(id) {
|
|
let channelId;
|
|
let local;
|
|
id = id.id;
|
|
({ channelId, local } = id);
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
if (null != orCreate) {
|
|
if (orCreate.has(id)) {
|
|
const obj3 = map;
|
|
if (map.has(id)) {
|
|
if (true !== local) {
|
|
return false;
|
|
} else {
|
|
obj3.delete(id);
|
|
}
|
|
}
|
|
let obj4 = orCreate;
|
|
if (orCreate.revealedMessageId === id) {
|
|
const after = orCreate.getAfter(id);
|
|
if (null != after) {
|
|
let mutation;
|
|
if (after.blocked) {
|
|
const obj2 = { revealedMessageId: after.id };
|
|
mutation = orCreate.mutate(obj2);
|
|
}
|
|
obj4 = mutation;
|
|
}
|
|
mutation = orCreate.mutate({ revealedMessageId: null });
|
|
}
|
|
const value = obj4.get(id);
|
|
if (null != value) {
|
|
const mediaMention = value.mediaMention;
|
|
let attachment_id;
|
|
if (mediaMention != null) {
|
|
attachment_id = mediaMention.attachment_id;
|
|
}
|
|
if (null != attachment_id) {
|
|
const tmpResult = ChannelMessagesDefault;
|
|
const value2 = tmpResult.get(attachment_id);
|
|
if (null != value2) {
|
|
const mediaMention2 = value.mediaMention;
|
|
let message_id;
|
|
if (mediaMention2 != null) {
|
|
message_id = mediaMention2.message_id;
|
|
}
|
|
if (null != message_id) {
|
|
const removeResult = value2.remove(message_id);
|
|
const tmpResult3 = ChannelMessagesDefault;
|
|
tmpResult3.commit(removeResult);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const removeResult1 = obj4.remove(id);
|
|
const tmpResult4 = ChannelMessagesDefault;
|
|
tmpResult4.commit(removeResult1);
|
|
set.delete(id);
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
MESSAGE_DELETE_BULK: function handleMessageDeleteBulk(ids) {
|
|
ids = ids.ids;
|
|
let mutation;
|
|
const channelId = ids.channelId;
|
|
obj = mutation(5585);
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
if (null == orCreate) {
|
|
return false;
|
|
} else {
|
|
const item = ids.forEach((item) => {
|
|
const value = orCreate.get(item);
|
|
if (null != value) {
|
|
const mediaMention = value.mediaMention;
|
|
let attachment_id;
|
|
if (mediaMention != null) {
|
|
attachment_id = mediaMention.attachment_id;
|
|
}
|
|
if (null != attachment_id) {
|
|
obj = ChannelMessagesDefault;
|
|
const value2 = obj.get(attachment_id);
|
|
const tmp3 = importDefault;
|
|
if (null != value2) {
|
|
const mediaMention2 = value.mediaMention;
|
|
let message_id;
|
|
if (mediaMention2 != null) {
|
|
message_id = mediaMention2.message_id;
|
|
}
|
|
if (null != message_id) {
|
|
const removeResult = value2.remove(message_id);
|
|
const tmp3Result = tmp3(5585);
|
|
tmp3Result.commit(removeResult);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
const removeManyResult = orCreate.removeMany(ids);
|
|
mutation = removeManyResult;
|
|
if (orCreate === removeManyResult) {
|
|
return false;
|
|
} else {
|
|
let tmp5 = removeManyResult;
|
|
if (null != removeManyResult.revealedMessageId) {
|
|
tmp5 = removeManyResult;
|
|
const tmpResult = mutation(12);
|
|
if (tmpResult.some(ids, (arg0) => mutation.revealedMessageId === arg0)) {
|
|
const after = removeManyResult.getAfter(removeManyResult.revealedMessageId);
|
|
if (null != after) {
|
|
if (after.blocked) {
|
|
const obj2 = { revealedMessageId: after.id };
|
|
mutation = removeManyResult.mutate(obj2);
|
|
}
|
|
tmp5 = mutation;
|
|
}
|
|
mutation = removeManyResult.mutate({ revealedMessageId: null });
|
|
}
|
|
}
|
|
const tmpResult2 = mutation(5585);
|
|
tmpResult2.commit(tmp5);
|
|
const item1 = ids.forEach((item) => {
|
|
set.delete(item);
|
|
});
|
|
}
|
|
}
|
|
},
|
|
MESSAGE_REVEAL: function handleMessageReveal(arg0) {
|
|
let channelId;
|
|
let messageId;
|
|
({ channelId, messageId } = arg0);
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
const obj3 = ChannelMessagesDefault;
|
|
obj3.commit(orCreate.mutate({ revealedMessageId: messageId }));
|
|
},
|
|
THREAD_CREATE_LOCAL: function handleThreadCreateLocal(channelId) {
|
|
channelId = channelId.channelId;
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(channelId);
|
|
const complete = orCreate.loadComplete({ newMessages: [], hasMoreAfter: false, hasMoreBefore: false });
|
|
const obj3 = ChannelMessagesDefault;
|
|
obj3.commit(complete);
|
|
},
|
|
CHANNEL_UPDATES: function handleChannelUpdates(channels) {
|
|
channels = channels.channels;
|
|
let flag = false;
|
|
obj = _modDef12;
|
|
const uniqResult = obj.uniq(channels.map((guild_id) => guild_id.guild_id));
|
|
const tmp2 = uniqResult[Symbol.iterator]();
|
|
while (tmp2 !== undefined) {
|
|
if (invalidateInaccessibleMessages(tmp3)) {
|
|
flag = true;
|
|
}
|
|
continue;
|
|
}
|
|
return flag;
|
|
},
|
|
GUILD_ROLE_UPDATE: handleRoleUpdate,
|
|
GUILD_ROLE_DELETE: handleRoleUpdate,
|
|
GUILD_MEMBER_UPDATE: function handleMemberUpdate(user) {
|
|
const id = user.user.id;
|
|
const currentUser = UserStore.getCurrentUser();
|
|
let id1;
|
|
if (currentUser != null) {
|
|
id1 = currentUser.id;
|
|
}
|
|
let tmp3 = id === id1;
|
|
if (tmp3) {
|
|
const guildId = user.guildId;
|
|
importDefault = false;
|
|
const arr = ChannelMessagesDefault;
|
|
const item = arr.forEach((cached) => {
|
|
if (!cached.cached) {
|
|
const basicChannel = ChannelStore.getBasicChannel(cached.channelId);
|
|
let guild_id;
|
|
if (basicChannel != null) {
|
|
guild_id = basicChannel.guild_id;
|
|
}
|
|
if (guild_id === guildId) {
|
|
if (!PermissionStore.canBasicChannel(constants.VIEW_CHANNEL, basicChannel)) {
|
|
obj = ChannelMessagesDefault;
|
|
obj.commit(cached.mutate({ cached: true }));
|
|
c1 = true;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
tmp3 = importDefault;
|
|
}
|
|
return tmp3;
|
|
},
|
|
CHANNEL_DELETE: handleCleanup,
|
|
THREAD_DELETE: handleCleanup,
|
|
GUILD_DELETE: handleCleanup,
|
|
RELATIONSHIP_ADD: handleRelationshipUpdate,
|
|
RELATIONSHIP_UPDATE: handleRelationshipUpdate,
|
|
RELATIONSHIP_REMOVE: handleRelationshipUpdate,
|
|
GUILD_MEMBERS_CHUNK_BATCH: function handleGuildMembersChunkBatch(arg0) {
|
|
const tmp = arg0.chunks[Symbol.iterator]();
|
|
while (tmp !== undefined) {
|
|
let tmp4 = performAuthorUpdate(tmp2.guildId);
|
|
continue;
|
|
}
|
|
},
|
|
THREAD_MEMBER_LIST_UPDATE: function handleThreadMemberListUpdate(guildId) {
|
|
guildId = guildId.guildId;
|
|
const arr = ChannelMessagesDefault;
|
|
let item = arr.forEach((channelId) => {
|
|
const channel = ChannelStore.getChannel(channelId.channelId);
|
|
let guild_id;
|
|
if (channel != null) {
|
|
guild_id = channel.guild_id;
|
|
}
|
|
if (guild_id === guildId) {
|
|
const items = [];
|
|
let c1 = false;
|
|
const item = channelId.forEach((nick) => {
|
|
let colorString;
|
|
obj = guildId(closure_2_2[27]);
|
|
const messageAuthor = obj.getMessageAuthor(nick);
|
|
({ nick, colorString } = messageAuthor);
|
|
if (nick === nick.nick) {
|
|
if (colorString === nick.colorString) {
|
|
items.push(nick);
|
|
}
|
|
}
|
|
c1 = true;
|
|
items.push(nick.merge({ nick, colorString }));
|
|
});
|
|
const tmp4 = c1;
|
|
if (tmp4) {
|
|
obj = ChannelMessagesDefault;
|
|
obj.commit(channelId.reset(items));
|
|
}
|
|
}
|
|
});
|
|
},
|
|
MESSAGE_REACTION_ADD: handleReaction,
|
|
MESSAGE_REACTION_ADD_MANY: function handleReactionBatch(reactions) {
|
|
let channelId;
|
|
let messageId;
|
|
reactions = reactions.reactions;
|
|
({ channelId, messageId } = reactions);
|
|
let tmp = importDefault;
|
|
obj = ChannelMessagesDefault;
|
|
const value = obj.get(channelId);
|
|
if (null == value) {
|
|
return false;
|
|
} else {
|
|
const updateResult = value.update(messageId, (addReactionBatch) => {
|
|
addReactionBatch = addReactionBatch.addReactionBatch;
|
|
const currentUser = UserStore.getCurrentUser();
|
|
let id;
|
|
const tmp = reactions;
|
|
if (currentUser != null) {
|
|
id = currentUser.id;
|
|
}
|
|
return addReactionBatch(tmp, id);
|
|
});
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(updateResult);
|
|
}
|
|
},
|
|
MESSAGE_REACTION_REMOVE: handleReaction,
|
|
MESSAGE_REACTION_REMOVE_ALL: function handleRemoveAllReactions(arg0) {
|
|
let channelId;
|
|
let messageId;
|
|
({ channelId, messageId } = arg0);
|
|
obj = ChannelMessagesDefault;
|
|
const value = obj.get(channelId);
|
|
if (null == value) {
|
|
return false;
|
|
} else {
|
|
const updateResult = value.update(messageId, (set) => set.set("reactions", []));
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(updateResult);
|
|
}
|
|
},
|
|
MESSAGE_REACTION_REMOVE_EMOJI: function handleRemoveEmojiReactions(emoji) {
|
|
let channelId;
|
|
let messageId;
|
|
emoji = emoji.emoji;
|
|
({ channelId, messageId } = emoji);
|
|
obj = ChannelMessagesDefault;
|
|
const value = obj.get(channelId);
|
|
if (null == value) {
|
|
return false;
|
|
} else {
|
|
const updateResult = value.update(messageId, (removeReactionsForEmoji) => removeReactionsForEmoji.removeReactionsForEmoji(emoji));
|
|
const tmpResult = ChannelMessagesDefault;
|
|
tmpResult.commit(updateResult);
|
|
}
|
|
},
|
|
LOGOUT: function handleLogout() {
|
|
const arr = ChannelMessagesDefault;
|
|
const item = arr.forEach((channelId) => {
|
|
obj = ChannelMessagesDefault;
|
|
obj.clear(channelId.channelId);
|
|
});
|
|
set.clear();
|
|
},
|
|
UPLOAD_START: function handleUploadStart(message) {
|
|
message = message.message;
|
|
let nonce;
|
|
if (message != null) {
|
|
nonce = message.nonce;
|
|
}
|
|
if (null != nonce) {
|
|
set.add(message.nonce);
|
|
}
|
|
},
|
|
UPLOAD_FAIL: function handleUploadFail(messageId) {
|
|
messageId = messageId.messageId;
|
|
if (null == messageId) {
|
|
return false;
|
|
} else {
|
|
const obj5 = set;
|
|
if (set.has(messageId)) {
|
|
obj = ChannelMessagesDefault;
|
|
const orCreate = obj.getOrCreate(tmp);
|
|
const value = orCreate.get(messageId);
|
|
const tmp2 = importDefault;
|
|
if (null == value) {
|
|
return false;
|
|
} else {
|
|
const items = [value];
|
|
const removeResult = orCreate.remove(messageId);
|
|
const mergeResult = removeResult.merge(items);
|
|
obj5.delete(messageId);
|
|
const tmp2Result = tmp2(5585);
|
|
tmp2Result.commit(mergeResult);
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
LOCAL_MESSAGE_CREATE: function handleLocalIncomingMesssage(message) {
|
|
message = message.message;
|
|
const currentUser = UserStore.getCurrentUser();
|
|
const tmp2 = null != message && null != message.author && null != currentUser && message.author.id === currentUser.id;
|
|
if (tmp2) {
|
|
c29 = true;
|
|
}
|
|
}
|
|
};
|
|
const messageStore = new MessageStore(DispatcherDefault, obj);
|
|
let result = size.fileFinishedImporting("stores/MessageStore.tsx");
|
|
|
|
export default messageStore;
|