678 lines
23 KiB
TypeScript
678 lines
23 KiB
TypeScript
// Module ID: 5984
|
|
// Function ID: 5985
|
|
// Name: updateState
|
|
// Dependencies: [1395, 3999, 1930, 1391, 4584, 1235, 676, 12, 11, 4586, 589, 709, 2]
|
|
|
|
// Module 5984 (updateState)
|
|
import createChannelRecord from "createChannelRecord";
|
|
import hasFlag from "hasFlag";
|
|
import createdAt from "createdAt";
|
|
import ensureGuildLoaded from "ensureGuildLoaded";
|
|
import reinjectEphemerals from "reinjectEphemerals";
|
|
import { MAX_THREAD_MESSAGE_COUNT } from "AbortCodes";
|
|
import { MessageTypes } from "ME";
|
|
import { Store } from "initialize";
|
|
import set from "createdAt";
|
|
|
|
let c3;
|
|
let c4;
|
|
function updateState(type) {
|
|
let messageCount;
|
|
if (set.has(type.type)) {
|
|
if (!(type.id in dependencyMap)) {
|
|
const obj = { guildId: null, parentId: null, count: null, mostRecentRawMessage: null, mostRecentMessage: null };
|
|
({ guild_id: obj[0], parent_id: obj[1], messageCount } = type);
|
|
if (messageCount == null) {
|
|
messageCount = 0;
|
|
}
|
|
obj[2] = messageCount;
|
|
dependencyMap[type.id] = obj;
|
|
const tmp2 = dependencyMap;
|
|
}
|
|
let num = dependencyMap2[tmp5.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
dependencyMap2[dependencyMap[type.id].parentId] = num + 1;
|
|
arg1(dependencyMap[type.id]);
|
|
}
|
|
}
|
|
function updateFromGuild(threads) {
|
|
threads = threads.threads;
|
|
if (threads != null) {
|
|
const item = threads.forEach(updateFromThread);
|
|
}
|
|
const threadMessages = threads.threadMessages;
|
|
if (threadMessages != null) {
|
|
const item1 = threadMessages.forEach(updateFromThreadMessages);
|
|
}
|
|
}
|
|
function updateFromThreadMessages(type) {
|
|
let messageCount;
|
|
let closure_0 = type;
|
|
if (type.type !== MessageTypes.THREAD_STARTER_MESSAGE) {
|
|
const channel = store.getChannel(type.channel_id);
|
|
if (null != channel) {
|
|
if (set.has(channel.type)) {
|
|
if (!(channel.id in dependencyMap)) {
|
|
const obj = { guildId: null, parentId: null, count: null, mostRecentRawMessage: null, mostRecentMessage: null };
|
|
({ guild_id: obj[0], parent_id: obj[1], messageCount } = channel);
|
|
if (messageCount == null) {
|
|
messageCount = 0;
|
|
}
|
|
obj[2] = messageCount;
|
|
dependencyMap[channel.id] = obj;
|
|
const tmp2 = dependencyMap;
|
|
}
|
|
let num = dependencyMap2[tmp4.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
dependencyMap2[dependencyMap[channel.id].parentId] = num + 1;
|
|
((arg0) => {
|
|
arg0.mostRecentRawMessage = closure_0;
|
|
arg0.mostRecentMessage = null;
|
|
})(dependencyMap[channel.id]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function updateFromThread(type) {
|
|
let messageCount;
|
|
let closure_0 = type;
|
|
if (set.has(type.type)) {
|
|
if (!(type.id in dependencyMap)) {
|
|
const obj = { guildId: null, parentId: null, count: null, mostRecentRawMessage: null, mostRecentMessage: null };
|
|
({ guild_id: obj[0], parent_id: obj[1], messageCount } = type);
|
|
if (messageCount == null) {
|
|
messageCount = 0;
|
|
}
|
|
obj[2] = messageCount;
|
|
dependencyMap[type.id] = obj;
|
|
const tmp2 = dependencyMap;
|
|
}
|
|
let num = dependencyMap2[tmp5.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
dependencyMap2[dependencyMap[type.id].parentId] = num + 1;
|
|
((mostRecentRawMessage) => {
|
|
if (null != channel.messageCount) {
|
|
mostRecentRawMessage.count = tmp.messageCount;
|
|
}
|
|
let mostRecentMessage = mostRecentRawMessage.mostRecentRawMessage;
|
|
if (mostRecentMessage == null) {
|
|
mostRecentMessage = mostRecentRawMessage.mostRecentMessage;
|
|
}
|
|
let tmp2 = null != tmp.lastMessageId;
|
|
if (tmp2) {
|
|
let id;
|
|
if (mostRecentMessage != null) {
|
|
id = mostRecentMessage.id;
|
|
}
|
|
tmp2 = id !== tmp.lastMessageId;
|
|
}
|
|
if (tmp2) {
|
|
mostRecentRawMessage.mostRecentRawMessage = null;
|
|
mostRecentRawMessage.mostRecentMessage = null;
|
|
}
|
|
})(dependencyMap[type.id]);
|
|
}
|
|
}
|
|
function updateFromServerThread(id) {
|
|
let messageCount;
|
|
if (null != id) {
|
|
if (!(id.id in dependencyMap)) {
|
|
const channel = store.getChannel(id.id);
|
|
if (null != channel) {
|
|
if (set.has(channel.type)) {
|
|
if (!(channel.id in dependencyMap)) {
|
|
const obj = { guildId: null, parentId: null, count: null, mostRecentRawMessage: null, mostRecentMessage: null };
|
|
({ guild_id: obj[0], parent_id: obj[1], messageCount } = channel);
|
|
if (messageCount == null) {
|
|
messageCount = 0;
|
|
}
|
|
obj[2] = messageCount;
|
|
dependencyMap[channel.id] = obj;
|
|
const tmp4 = dependencyMap;
|
|
}
|
|
let num = dependencyMap2[tmp6.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
dependencyMap2[dependencyMap[channel.id].parentId] = num + 1;
|
|
((mostRecentRawMessage) => {
|
|
if (null != channel.messageCount) {
|
|
mostRecentRawMessage.count = tmp.messageCount;
|
|
}
|
|
let mostRecentMessage = mostRecentRawMessage.mostRecentRawMessage;
|
|
if (mostRecentMessage == null) {
|
|
mostRecentMessage = mostRecentRawMessage.mostRecentMessage;
|
|
}
|
|
let tmp2 = null != tmp.lastMessageId;
|
|
if (tmp2) {
|
|
let id;
|
|
if (mostRecentMessage != null) {
|
|
id = mostRecentMessage.id;
|
|
}
|
|
tmp2 = id !== tmp.lastMessageId;
|
|
}
|
|
if (tmp2) {
|
|
mostRecentRawMessage.mostRecentRawMessage = null;
|
|
mostRecentRawMessage.mostRecentMessage = null;
|
|
}
|
|
})(dependencyMap[channel.id]);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function handleThreadCreateOrUpdate(channel) {
|
|
let messageCount;
|
|
channel = channel.channel;
|
|
if (set.has(channel.type)) {
|
|
if (!(channel.id in dependencyMap)) {
|
|
const obj = { guildId: null, parentId: null, count: null, mostRecentRawMessage: null, mostRecentMessage: null };
|
|
({ guild_id: obj[0], parent_id: obj[1], messageCount } = channel);
|
|
if (messageCount == null) {
|
|
messageCount = 0;
|
|
}
|
|
obj[2] = messageCount;
|
|
dependencyMap[channel.id] = obj;
|
|
const tmp2 = dependencyMap;
|
|
}
|
|
let num = dependencyMap2[tmp5.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
dependencyMap2[dependencyMap[channel.id].parentId] = num + 1;
|
|
((mostRecentRawMessage) => {
|
|
if (null != channel.messageCount) {
|
|
mostRecentRawMessage.count = tmp.messageCount;
|
|
}
|
|
let mostRecentMessage = mostRecentRawMessage.mostRecentRawMessage;
|
|
if (mostRecentMessage == null) {
|
|
mostRecentMessage = mostRecentRawMessage.mostRecentMessage;
|
|
}
|
|
let tmp2 = null != tmp.lastMessageId;
|
|
if (tmp2) {
|
|
let id;
|
|
if (mostRecentMessage != null) {
|
|
id = mostRecentMessage.id;
|
|
}
|
|
tmp2 = id !== tmp.lastMessageId;
|
|
}
|
|
if (tmp2) {
|
|
mostRecentRawMessage.mostRecentRawMessage = null;
|
|
mostRecentRawMessage.mostRecentMessage = null;
|
|
}
|
|
})(dependencyMap[channel.id]);
|
|
}
|
|
}
|
|
function handleLoadArchivedThreadsSuccess(threads) {
|
|
threads = threads.threads;
|
|
const item = threads.forEach(updateFromServerThread);
|
|
}
|
|
function handleSearchMessagesSuccess(data) {
|
|
data = data.data;
|
|
let item = data.forEach((arg0) => {
|
|
let messages;
|
|
let threads;
|
|
({ messages, threads } = arg0);
|
|
let item = messages.forEach((arr) => {
|
|
const item = arr.forEach((thread) => {
|
|
let messageCount;
|
|
thread = thread.thread;
|
|
if (null != thread) {
|
|
if (!(thread.id in table)) {
|
|
channel = channel.getChannel(thread.id);
|
|
if (null != channel) {
|
|
if (set.has(channel.type)) {
|
|
if (!(channel.id in table)) {
|
|
const obj = { guildId: null, parentId: null, count: null, mostRecentRawMessage: null, mostRecentMessage: null };
|
|
({ guild_id: obj[0], parent_id: obj[1], messageCount } = channel);
|
|
if (messageCount == null) {
|
|
messageCount = 0;
|
|
}
|
|
obj[2] = messageCount;
|
|
table[channel.id] = obj;
|
|
const tmp4 = table;
|
|
}
|
|
let num = table2[tmp6.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
table2[table[channel.id].parentId] = num + 1;
|
|
((mostRecentRawMessage) => {
|
|
if (null != channel.messageCount) {
|
|
mostRecentRawMessage.count = tmp.messageCount;
|
|
}
|
|
let mostRecentMessage = mostRecentRawMessage.mostRecentRawMessage;
|
|
if (mostRecentMessage == null) {
|
|
mostRecentMessage = mostRecentRawMessage.mostRecentMessage;
|
|
}
|
|
let tmp2 = null != tmp.lastMessageId;
|
|
if (tmp2) {
|
|
let id;
|
|
if (mostRecentMessage != null) {
|
|
id = mostRecentMessage.id;
|
|
}
|
|
tmp2 = id !== tmp.lastMessageId;
|
|
}
|
|
if (tmp2) {
|
|
mostRecentRawMessage.mostRecentRawMessage = null;
|
|
mostRecentRawMessage.mostRecentMessage = null;
|
|
}
|
|
})(table[channel.id]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
});
|
|
const item1 = threads.forEach(closure_18);
|
|
});
|
|
}
|
|
function handleRelationshipUpdate() {
|
|
for (const key10003 in closure_12) {
|
|
let tmp3 = key10003;
|
|
let tmp4 = dependencyMap;
|
|
let tmp5 = dependencyMap[key10003];
|
|
if (null == tmp5) {
|
|
continue;
|
|
} else {
|
|
if (null == tmp5.mostRecentMessage) {
|
|
continue;
|
|
} else {
|
|
let tmp = store2;
|
|
let message = store2.getMessage(key10003, tmp5.mostRecentMessage.id);
|
|
if (null == message) {
|
|
continue;
|
|
} else {
|
|
tmp5.mostRecentMessage = message;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
({ ALL_CHANNEL_TYPES: c3, THREAD_CHANNEL_TYPES: c4 } = createChannelRecord);
|
|
let set = new Set();
|
|
let closure_12 = {};
|
|
let closure_13 = {};
|
|
class ThreadMessageStore extends Store {
|
|
}
|
|
const prototype = ThreadMessageStore.prototype;
|
|
prototype["initialize"] = function initialize() {
|
|
this.waitFor(ensureGuildLoaded, reinjectEphemerals);
|
|
};
|
|
prototype["getCount"] = function getCount(arg0) {
|
|
let count;
|
|
if (dependencyMap[arg0] != null) {
|
|
count = tmp.count;
|
|
}
|
|
if (count == null) {
|
|
count = null;
|
|
}
|
|
return count;
|
|
};
|
|
prototype["getMostRecentMessage"] = function getMostRecentMessage(id) {
|
|
let tmp2 = null;
|
|
if (null != dependencyMap[id]) {
|
|
if (tmp3) {
|
|
let message = store2.getMessage(id, tmp.mostRecentRawMessage.id);
|
|
if (message == null) {
|
|
message = require(4586) /* createMinimalMessageRecord */.createMessageRecord(tmp.mostRecentRawMessage);
|
|
const obj = require(4586) /* createMinimalMessageRecord */;
|
|
}
|
|
tmp.mostRecentMessage = message;
|
|
tmp.mostRecentRawMessage = null;
|
|
}
|
|
let mostRecentMessage = tmp.mostRecentMessage;
|
|
if (mostRecentMessage == null) {
|
|
mostRecentMessage = null;
|
|
}
|
|
tmp2 = mostRecentMessage;
|
|
tmp3 = null == tmp.mostRecentMessage && null != tmp.mostRecentRawMessage;
|
|
}
|
|
return tmp2;
|
|
};
|
|
prototype["getChannelThreadsVersion"] = function getChannelThreadsVersion(memo1) {
|
|
return dependencyMap2[memo1];
|
|
};
|
|
prototype["getInitialOverlayState"] = function getInitialOverlayState() {
|
|
return closure_12;
|
|
};
|
|
ThreadMessageStore.displayName = "ThreadMessageStore";
|
|
const threadMessageStore = new ThreadMessageStore(require("dispatcher"), {
|
|
CONNECTION_OPEN: function handleConnectionOpen(guilds) {
|
|
let closure_13 = {};
|
|
set.clear();
|
|
guilds = guilds.guilds;
|
|
const item = guilds.forEach(updateFromGuild);
|
|
},
|
|
OVERLAY_INITIALIZE: function handleOverlayInitialize(threadMessages) {
|
|
threadMessages = threadMessages.threadMessages;
|
|
let obj = {};
|
|
const merged = Object.assign(threadMessages);
|
|
for (const key10009 in obj) {
|
|
let tmp16 = key10009;
|
|
let mostRecentMessage = threadMessages[key10009].mostRecentMessage;
|
|
if (null == mostRecentMessage) {
|
|
continue;
|
|
} else {
|
|
let tmp2 = hasFlag;
|
|
obj = {};
|
|
let tmp3 = obj;
|
|
let tmp4 = mostRecentMessage;
|
|
let merged1 = Object.assign(mostRecentMessage);
|
|
let tmp6 = createdAt;
|
|
let tmp7 = new.target;
|
|
let tmp8 = new.target;
|
|
let tmp9 = new createdAt(mostRecentMessage.author);
|
|
let tmp10 = tmp9;
|
|
obj.author = tmp9;
|
|
let tmp11 = new.target;
|
|
let tmp12 = new.target;
|
|
let tmp13 = obj;
|
|
let tmp14 = new hasFlag(obj);
|
|
let tmp15 = tmp14;
|
|
threadMessages[key10009].mostRecentMessage = tmp14;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
},
|
|
GUILD_CREATE: function handleGuildCreate(guild) {
|
|
guild = guild.guild;
|
|
const threads = guild.threads;
|
|
if (threads != null) {
|
|
const item = threads.forEach(updateFromThread);
|
|
}
|
|
const threadMessages = guild.threadMessages;
|
|
if (threadMessages != null) {
|
|
const item1 = threadMessages.forEach(updateFromThreadMessages);
|
|
}
|
|
},
|
|
GUILD_DELETE: function handleGuildDelete(guild) {
|
|
const id = guild.guild.id;
|
|
closure_12 = importDefault(12).omitBy(closure_12, (guildId) => {
|
|
if (guildId.guildId === id) {
|
|
const parentId = guildId.parentId;
|
|
delete tmp2[tmp];
|
|
}
|
|
return guildId.guildId === id;
|
|
});
|
|
},
|
|
THREAD_CREATE: handleThreadCreateOrUpdate,
|
|
THREAD_UPDATE: handleThreadCreateOrUpdate,
|
|
THREAD_LIST_SYNC: function handleThreadListSync(arg0) {
|
|
let mostRecentMessages;
|
|
let threads;
|
|
({ threads, mostRecentMessages } = arg0);
|
|
const item = threads.forEach(updateFromThread);
|
|
if (mostRecentMessages != null) {
|
|
const item1 = mostRecentMessages.forEach((channel_id) => {
|
|
let messageCount;
|
|
let closure_0 = channel_id;
|
|
channel = channel.getChannel(channel_id.channel_id);
|
|
let tmp2 = null != channel;
|
|
if (tmp2) {
|
|
tmp2 = channel_id.type !== constants.THREAD_STARTER_MESSAGE;
|
|
}
|
|
if (tmp2) {
|
|
if (set.has(channel.type)) {
|
|
if (!(channel.id in table)) {
|
|
const obj = { guildId: null, parentId: null, count: null, mostRecentRawMessage: null, mostRecentMessage: null };
|
|
({ guild_id: obj[0], parent_id: obj[1], messageCount } = channel);
|
|
if (messageCount == null) {
|
|
messageCount = 0;
|
|
}
|
|
obj[2] = messageCount;
|
|
table[channel.id] = obj;
|
|
const tmp6 = table;
|
|
}
|
|
let num = table2[tmp8.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
table2[table[channel.id].parentId] = num + 1;
|
|
((arg0) => {
|
|
arg0.mostRecentRawMessage = closure_0;
|
|
arg0.mostRecentMessage = null;
|
|
})(table[channel.id]);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
},
|
|
LOAD_THREADS_SUCCESS: handleLoadArchivedThreadsSuccess,
|
|
LOAD_ARCHIVED_THREADS_SUCCESS: handleLoadArchivedThreadsSuccess,
|
|
RELATIONSHIP_ADD: handleRelationshipUpdate,
|
|
RELATIONSHIP_UPDATE: handleRelationshipUpdate,
|
|
RELATIONSHIP_REMOVE: handleRelationshipUpdate,
|
|
SEARCH_MESSAGES_SUCCESS: handleSearchMessagesSuccess,
|
|
MOD_VIEW_SEARCH_MESSAGES_SUCCESS: handleSearchMessagesSuccess,
|
|
THREAD_DELETE: function handleThreadDelete(arg0) {
|
|
delete tmp2[tmp];
|
|
},
|
|
CHANNEL_DELETE: function handleChannelDelete(channel) {
|
|
const id = channel.channel.id;
|
|
closure_12 = importDefault(12).omitBy(closure_12, (parentId) => parentId.parentId === id);
|
|
delete tmp[tmp2];
|
|
},
|
|
MESSAGE_CREATE: function handleMessageCreate(message) {
|
|
let messageCount;
|
|
message = message.message;
|
|
if (!message.optimistic) {
|
|
if (!message.isPushNotification) {
|
|
if (null == tmp) {
|
|
const channel = store.getChannel(message.channel_id);
|
|
let tmp4 = null == channel;
|
|
if (!tmp4) {
|
|
tmp4 = !set2.has(channel.type);
|
|
}
|
|
let tmp5 = !tmp4;
|
|
if (!tmp4) {
|
|
let tmp7 = message.type !== MessageTypes.THREAD_STARTER_MESSAGE;
|
|
if (tmp7) {
|
|
const isForumPostResult = channel.isForumPost();
|
|
let tmp9 = !isForumPostResult;
|
|
if (isForumPostResult) {
|
|
let obj = importDefault(11);
|
|
tmp9 = message.id !== obj.castChannelIdAsMessageId(channel.id);
|
|
}
|
|
tmp7 = tmp9;
|
|
}
|
|
if (tmp7) {
|
|
if (set.has(channel.type)) {
|
|
if (!(channel.id in dependencyMap)) {
|
|
obj = { guildId: null, parentId: null, count: null, mostRecentRawMessage: null, mostRecentMessage: null };
|
|
({ guild_id: obj2[0], parent_id: obj2[1], messageCount } = channel);
|
|
if (messageCount == null) {
|
|
messageCount = 0;
|
|
}
|
|
obj[2] = messageCount;
|
|
dependencyMap[channel.id] = obj;
|
|
const tmp15 = dependencyMap;
|
|
}
|
|
let num = dependencyMap2[tmp17.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
dependencyMap2[dependencyMap[channel.id].parentId] = num + 1;
|
|
((count) => {
|
|
count.count = Math.min(count.count + 1, outer1_9);
|
|
count.mostRecentRawMessage = message;
|
|
count.mostRecentMessage = null;
|
|
})(dependencyMap[channel.id]);
|
|
}
|
|
}
|
|
tmp5 = tmp12;
|
|
}
|
|
return tmp5;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
MESSAGE_UPDATE: function handleMessageUpdate(message) {
|
|
message = message.message;
|
|
let mostRecentRawMessage;
|
|
if (dependencyMap[message.channel_id] != null) {
|
|
mostRecentRawMessage = tmp.mostRecentRawMessage;
|
|
}
|
|
if (mostRecentRawMessage == null) {
|
|
let mostRecentMessage;
|
|
if (tmp != null) {
|
|
mostRecentMessage = tmp.mostRecentMessage;
|
|
}
|
|
mostRecentRawMessage = mostRecentMessage;
|
|
}
|
|
if (null != dependencyMap[message.channel_id]) {
|
|
if (null != mostRecentRawMessage) {
|
|
if (mostRecentRawMessage.id === message.id) {
|
|
let num = dependencyMap2[tmp.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
dependencyMap2[tmp.parentId] = num + 1;
|
|
if (null != tmp.mostRecentMessage) {
|
|
tmp.mostRecentMessage = require(4586) /* createMinimalMessageRecord */.updateMessageRecord(tmp.mostRecentMessage, message);
|
|
const obj = require(4586) /* createMinimalMessageRecord */;
|
|
}
|
|
if (null != tmp.mostRecentRawMessage) {
|
|
tmp.mostRecentRawMessage = require(4586) /* createMinimalMessageRecord */.updateServerMessage(tmp.mostRecentRawMessage, message);
|
|
const obj2 = require(4586) /* createMinimalMessageRecord */;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
MESSAGE_DELETE: function handleMessageDelete(arg0) {
|
|
let channelId;
|
|
let id;
|
|
({ id, channelId } = arg0);
|
|
if (null == dependencyMap[channelId]) {
|
|
return false;
|
|
} else {
|
|
const result = importDefault(11).castChannelIdAsMessageId(channelId);
|
|
const hasItem = set.has(id);
|
|
let num = dependencyMap2[tmp.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
dependencyMap2[tmp.parentId] = num + 1;
|
|
let mostRecentMessage = tmp.mostRecentRawMessage;
|
|
if (mostRecentMessage == null) {
|
|
mostRecentMessage = tmp.mostRecentMessage;
|
|
}
|
|
if (tmp3) {
|
|
tmp.mostRecentMessage = null;
|
|
tmp.mostRecentRawMessage = null;
|
|
}
|
|
if (result !== id) {
|
|
if (!hasItem) {
|
|
const _Math = Math;
|
|
let count = Math.max(tmp.count - 1, 0);
|
|
}
|
|
tmp.count = count;
|
|
obj2.add(id);
|
|
}
|
|
count = tmp.count;
|
|
const obj = importDefault(11);
|
|
obj2 = set;
|
|
tmp3 = null != mostRecentMessage && mostRecentMessage.id === id;
|
|
}
|
|
},
|
|
MESSAGE_DELETE_BULK: function handleMessageDeleteBulk(arg0) {
|
|
let channelId;
|
|
let ids;
|
|
({ ids, channelId } = arg0);
|
|
if (null == dependencyMap[channelId]) {
|
|
return false;
|
|
} else {
|
|
const length = ids.filter((arg0) => {
|
|
let tmp = outer1_1(outer1_2[8]).castChannelIdAsMessageId(channelId) !== arg0;
|
|
if (tmp) {
|
|
tmp = !outer1_11.has(arg0);
|
|
}
|
|
return tmp;
|
|
}).length;
|
|
if (length > 0) {
|
|
let num = dependencyMap2[tmp.parentId];
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
dependencyMap2[tmp.parentId] = num + 1;
|
|
let mostRecentMessage = tmp.mostRecentRawMessage;
|
|
if (mostRecentMessage == null) {
|
|
mostRecentMessage = tmp.mostRecentMessage;
|
|
}
|
|
if (tmp3) {
|
|
tmp.mostRecentMessage = null;
|
|
tmp.mostRecentRawMessage = null;
|
|
}
|
|
tmp.count = tmp.count - length;
|
|
const item = ids.forEach((arg0) => set.add(arg0));
|
|
tmp3 = null != mostRecentMessage && ids.includes(mostRecentMessage.id);
|
|
}
|
|
}
|
|
},
|
|
LOAD_MESSAGES_SUCCESS: function handleLoadMessagesSuccess(isAfter) {
|
|
let closure_0 = isAfter;
|
|
let flag = false;
|
|
for (const item10007 of tmp) {
|
|
let tmp2 = updateFromServerThread;
|
|
let tmp3 = updateFromServerThread(item10007.thread);
|
|
if (!tmp3) {
|
|
tmp3 = flag;
|
|
}
|
|
flag = tmp3;
|
|
continue;
|
|
}
|
|
if (!isAfter.isAfter) {
|
|
if (!isAfter.isBefore) {
|
|
if (!isAfter.hasMoreAfter) {
|
|
const channel = store.getChannel(isAfter.channelId);
|
|
if (null != channel) {
|
|
if (set2.has(channel.type)) {
|
|
updateState(channel, (count) => {
|
|
if (0 === isAfter.messages.length) {
|
|
count.mostRecentRawMessage = null;
|
|
count.mostRecentMessage = null;
|
|
count.count = 0;
|
|
} else {
|
|
let first = tmp.messages[0];
|
|
if (first == null) {
|
|
first = null;
|
|
}
|
|
count.count = tmp.messages.length >= outer1_9 ? outer1_9 : count.count;
|
|
let type;
|
|
if (first != null) {
|
|
type = first.type;
|
|
}
|
|
if (type !== outer1_10.THREAD_STARTER_MESSAGE) {
|
|
count.mostRecentRawMessage = first;
|
|
count.mostRecentMessage = null;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
});
|
|
let result = set.fileFinishedImporting("modules/threads/ThreadMessageStore.tsx");
|
|
|
|
export default threadMessageStore;
|