950 lines
29 KiB
TypeScript
950 lines
29 KiB
TypeScript
// Module ID: 5868
|
|
// Function ID: 51704
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: [6, 7, 15, 17, 18, 5869, 5872, 5040, 3761, 1352, 1194, 1348, 1838, 1196, 3759, 4143, 1907, 4326, 1850, 653, 1355, 4327, 5761, 21, 1841, 22, 3766, 2]
|
|
|
|
// Module 5868 (_isNativeReflectConstruct)
|
|
import _isNativeReflectConstruct from "_isNativeReflectConstruct";
|
|
import closure_4 from "_isNativeReflectConstruct";
|
|
import closure_5 from "_isNativeReflectConstruct";
|
|
import closure_6 from "_isNativeReflectConstruct";
|
|
import closure_7 from "_isNativeReflectConstruct";
|
|
import closure_8 from "_isNativeReflectConstruct";
|
|
import closure_9 from "_isNativeReflectConstruct";
|
|
import closure_10 from "_isNativeReflectConstruct";
|
|
import closure_11 from "_isNativeReflectConstruct";
|
|
import _callSuper from "_callSuper";
|
|
import closure_15 from "_isNativeReflectConstruct";
|
|
import closure_16 from "_isNativeReflectConstruct";
|
|
import _createForOfIteratorHelperLoose from "_createForOfIteratorHelperLoose";
|
|
import closure_18 from "_isNativeReflectConstruct";
|
|
import closure_19 from "_isNativeReflectConstruct";
|
|
import closure_20 from "_isNativeReflectConstruct";
|
|
import closure_21 from "_isNativeReflectConstruct";
|
|
import closure_22 from "_isNativeReflectConstruct";
|
|
import { ChannelFlags } from "set";
|
|
import ReadStateTypes from "ReadStateTypes";
|
|
import { NULL_STRING_GUILD_ID } from "ME";
|
|
import tmp6 from "_isNativeReflectConstruct";
|
|
import set from "_possibleConstructorReturn";
|
|
|
|
let closure_12;
|
|
let closure_13;
|
|
let closure_14;
|
|
let closure_24;
|
|
let closure_25;
|
|
let 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 createGuildState(guild_id) {
|
|
let tmp = guild_id;
|
|
if (null == guild_id) {
|
|
tmp = NULL_STRING_GUILD_ID;
|
|
}
|
|
const obj = { unread: false, unreadByType: {}, unreadChannelId: null, lowImportanceMentionCount: 0, highImportanceMentionCount: 0, mentionCounts: {}, ncMentionCount: 0 };
|
|
let sentinel;
|
|
if (null != closure_27[tmp]) {
|
|
sentinel = tmp3.sentinel;
|
|
}
|
|
let num = 0;
|
|
if (null != sentinel) {
|
|
num = sentinel;
|
|
}
|
|
obj.sentinel = num;
|
|
return obj;
|
|
}
|
|
function getOrCreateGuildState(guild_id) {
|
|
let tmp2 = guild_id;
|
|
if (null == guild_id) {
|
|
tmp2 = NULL_STRING_GUILD_ID;
|
|
}
|
|
let tmp4 = guild_id;
|
|
if (null == guild_id) {
|
|
tmp4 = NULL_STRING_GUILD_ID;
|
|
}
|
|
let tmp5 = closure_27[tmp4];
|
|
if (null == tmp5) {
|
|
tmp5 = createGuildState(guild_id);
|
|
}
|
|
closure_27[tmp2] = tmp5;
|
|
return tmp5;
|
|
}
|
|
function updateGuildUnreadSentinel(guild_id) {
|
|
const tmp = getOrCreateGuildState(guild_id);
|
|
tmp.sentinel = tmp.sentinel + 1;
|
|
closure_29 = closure_29 + 1;
|
|
}
|
|
function disableUnreadForOptInChannel(guild_id, mentionCount, result) {
|
|
let tmp = result;
|
|
let tmp2 = null != guild_id.guild_id;
|
|
if (tmp2) {
|
|
if (tmp) {
|
|
result = callback5(guild_id.type);
|
|
if (!result) {
|
|
result = store3.isChannelRecordOrParentOptedIn(guild_id);
|
|
}
|
|
tmp = !result;
|
|
}
|
|
if (tmp) {
|
|
tmp = 0 === mentionCount;
|
|
}
|
|
tmp2 = tmp;
|
|
}
|
|
return tmp2;
|
|
}
|
|
function isCountableChannel(channel, mentionCount) {
|
|
let num = mentionCount;
|
|
let flag = arg2;
|
|
if (mentionCount === undefined) {
|
|
num = 0;
|
|
}
|
|
if (flag === undefined) {
|
|
flag = false;
|
|
}
|
|
if (null == channel) {
|
|
return false;
|
|
} else {
|
|
if (channel.isGuildVocal()) {
|
|
if (0 === num) {
|
|
return false;
|
|
}
|
|
}
|
|
if (channel.hasFlag(ChannelFlags.IS_GUILD_RESOURCE_CHANNEL)) {
|
|
return false;
|
|
} else {
|
|
if (0 === num) {
|
|
if (channel.isThread()) {
|
|
let isMutedResult = closure_11.isMuted(channel.id);
|
|
if (!isMutedResult) {
|
|
isMutedResult = store3.isGuildOrCategoryOrChannelMuted(channel.guild_id, channel.parent_id);
|
|
}
|
|
let result = isMutedResult;
|
|
} else {
|
|
result = store3.isGuildOrCategoryOrChannelMuted(channel.guild_id, channel.id);
|
|
}
|
|
if (result) {
|
|
return false;
|
|
}
|
|
}
|
|
if (!channel.isPrivate()) {
|
|
if (disableUnreadForOptInChannel(channel, num, obj.isOptInEnabledForGuild(channel.guild_id))) {
|
|
return false;
|
|
} else if (!closure_18.can(channel.accessPermissions, channel)) {
|
|
return false;
|
|
}
|
|
obj = require(5761) /* useOptInEnabledForGuild */;
|
|
}
|
|
let tmp11 = num > 0;
|
|
if (!tmp11) {
|
|
tmp11 = store3.resolveUnreadSetting(channel) === constants2.ALL_MESSAGES;
|
|
}
|
|
return tmp11;
|
|
}
|
|
}
|
|
}
|
|
function computeIsCountableGuildChannel(type, mentionCount, result) {
|
|
let tmp = !callback4(type.type);
|
|
if (!tmp) {
|
|
tmp = 0 !== mentionCount;
|
|
}
|
|
if (tmp) {
|
|
const tmp4 = !closure_18.canBasicChannel(callback3(type.type), type);
|
|
let tmp5 = !tmp4;
|
|
if (!tmp4) {
|
|
let tmp8 = !disableUnreadForOptInChannel(type, mentionCount, result);
|
|
if (tmp8) {
|
|
let tmp10 = !tmp9;
|
|
if ("flags" in type) {
|
|
tmp10 = !type.hasFlag(ChannelFlags.IS_GUILD_RESOURCE_CHANNEL);
|
|
}
|
|
if (tmp10) {
|
|
let tmp12 = mentionCount > 0;
|
|
if (!tmp12) {
|
|
tmp12 = store3.resolveUnreadSetting(type) === constants2.ALL_MESSAGES;
|
|
}
|
|
tmp10 = tmp12;
|
|
}
|
|
tmp8 = tmp10;
|
|
}
|
|
tmp5 = tmp8;
|
|
}
|
|
tmp = tmp5;
|
|
}
|
|
return tmp;
|
|
}
|
|
function sanitizeGuildId(guildId) {
|
|
if (NULL_STRING_GUILD_ID !== guildId) {
|
|
if (null !== guildId) {
|
|
if (undefined !== guildId) {
|
|
return guildId;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
function isNonChannelUnread(guild_id, GUILD_EVENT) {
|
|
const hasUnreadResult = store2.hasUnread(guild_id, GUILD_EVENT);
|
|
let tmp2 = hasUnreadResult;
|
|
if (GUILD_EVENT === constants.GUILD_EVENT) {
|
|
let tmp4 = !store3.isMuted(guild_id);
|
|
if (tmp4) {
|
|
tmp4 = !store3.isMuteScheduledEventsEnabled(guild_id) && hasUnreadResult;
|
|
const tmp6 = !store3.isMuteScheduledEventsEnabled(guild_id) && hasUnreadResult;
|
|
}
|
|
tmp2 = tmp4;
|
|
}
|
|
return tmp2;
|
|
}
|
|
function createNewStateFrom(guild_id, mentionCounts) {
|
|
const tmp = createGuildState(guild_id);
|
|
let obj = {};
|
|
const merged = Object.assign(mentionCounts.mentionCounts);
|
|
tmp.mentionCounts = obj;
|
|
obj = {};
|
|
const merged1 = Object.assign(mentionCounts.unreadByType);
|
|
tmp.unreadByType = obj;
|
|
return tmp;
|
|
}
|
|
function updateGuildUnread(unreadByType) {
|
|
const entries = Object.entries(unreadByType.unreadByType);
|
|
unreadByType.unread = entries.some((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[tmp, tmp2] = arg0;
|
|
return Number(tmp) !== outer1_24.GUILD_EVENT && tmp2;
|
|
});
|
|
return unreadByType;
|
|
}
|
|
function updateNotificationCenterMentions(mentionCounts, ncMentionCount) {
|
|
if (!tabFocused.tabFocused) {
|
|
ncMentionCount = undefined;
|
|
const tmp3 = getGuildNotifCenterMentionCount(mentionCounts);
|
|
if (null != ncMentionCount) {
|
|
ncMentionCount = ncMentionCount.ncMentionCount;
|
|
}
|
|
let num2 = 0;
|
|
if (null != ncMentionCount) {
|
|
num2 = ncMentionCount;
|
|
}
|
|
mentionCounts.ncMentionCount = Math.max(num2 + (tmp3 - getGuildNotifCenterMentionCount(ncMentionCount)), 0);
|
|
const tmp4 = getGuildNotifCenterMentionCount(ncMentionCount);
|
|
}
|
|
}
|
|
function getGuildNotifCenterMentionCount(mentionCounts) {
|
|
let closure_0 = mentionCounts;
|
|
const importDefault = 0;
|
|
currentUser = currentUser.getCurrentUser();
|
|
let notifCenterReadState;
|
|
if (null != currentUser) {
|
|
notifCenterReadState = store2.getNotifCenterReadState(currentUser.id);
|
|
}
|
|
if (!tmp4) {
|
|
const keys = importDefault(notifCenterReadState[23]).keys(mentionCounts.mentionCounts);
|
|
const item = keys.forEach((arg0) => {
|
|
const lastMessageIdResult = outer1_19.lastMessageId(arg0);
|
|
if (obj.compare(lastMessageIdResult, notifCenterReadState._ackMessageId) > 0) {
|
|
closure_1 = closure_1 + mentionCounts.mentionCounts[arg0].count;
|
|
}
|
|
});
|
|
const obj = importDefault(notifCenterReadState[23]);
|
|
}
|
|
return importDefault;
|
|
}
|
|
function aggregateGuildState(guild_id, mentionCounts, unread) {
|
|
let tmp = guild_id;
|
|
let closure_0 = mentionCounts;
|
|
updateGuildUnread(mentionCounts);
|
|
mentionCounts.lowImportanceMentionCount = 0;
|
|
mentionCounts.highImportanceMentionCount = 0;
|
|
const item = importDefault(21).forEach(mentionCounts.mentionCounts, (count) => {
|
|
count = count.count;
|
|
if (count.isMentionLowImportance) {
|
|
tmp.lowImportanceMentionCount = tmp.lowImportanceMentionCount + count;
|
|
} else {
|
|
tmp.highImportanceMentionCount = tmp.highImportanceMentionCount + count;
|
|
}
|
|
});
|
|
let flag = mentionCounts.unread !== unread.unread || mentionCounts.lowImportanceMentionCount !== unread.lowImportanceMentionCount || mentionCounts.highImportanceMentionCount !== unread.highImportanceMentionCount;
|
|
if (flag) {
|
|
let tmp6 = tmp;
|
|
if (null == tmp) {
|
|
tmp6 = NULL_STRING_GUILD_ID;
|
|
}
|
|
closure_27[tmp6] = mentionCounts;
|
|
if (null != tmp) {
|
|
if (mentionCounts.unread) {
|
|
obj.add(tmp);
|
|
} else {
|
|
obj.delete(tmp);
|
|
}
|
|
}
|
|
closure_29 = closure_29 + 1;
|
|
if (null == tmp) {
|
|
tmp = NULL_STRING_GUILD_ID;
|
|
}
|
|
updateGuildUnreadSentinel(tmp);
|
|
updateNotificationCenterMentions(mentionCounts, unread);
|
|
flag = true;
|
|
const tmp10 = updateGuildUnreadSentinel;
|
|
const tmp4 = closure_27;
|
|
}
|
|
return flag;
|
|
}
|
|
function recountChannels(guildId, items) {
|
|
const tmp = sanitizeGuildId(guildId);
|
|
const require = tmp;
|
|
const tmp2 = getOrCreateGuildState(tmp);
|
|
const tmp3 = createNewStateFrom(tmp, tmp2);
|
|
const importDefault = tmp3;
|
|
let c2 = false;
|
|
const item = items.forEach((channelId) => {
|
|
const channel = outer1_16.getChannel(channelId);
|
|
if (null != channel) {
|
|
if (channel.getGuildId() === closure_0) {
|
|
const mentionCount = outer1_19.getMentionCount(channelId);
|
|
let hasUnreadResult = null !== closure_0;
|
|
if (hasUnreadResult) {
|
|
hasUnreadResult = !c2;
|
|
}
|
|
if (hasUnreadResult) {
|
|
hasUnreadResult = outer1_19.hasUnread(channel.id);
|
|
}
|
|
if (hasUnreadResult) {
|
|
hasUnreadResult = outer1_37(channel, mentionCount, true);
|
|
}
|
|
if (hasUnreadResult) {
|
|
c2 = true;
|
|
tmp3.unreadChannelId = channel.id;
|
|
}
|
|
if (mentionCount > 0) {
|
|
if (outer1_37(channel, mentionCount)) {
|
|
const obj = { count: mentionCount, isMentionLowImportance: outer1_19.getIsMentionLowImportance(channelId) };
|
|
tmp3.mentionCounts[channel.id] = obj;
|
|
}
|
|
}
|
|
const mentionCounts2 = tmp3.mentionCounts;
|
|
const id = channel.id;
|
|
delete tmp4[tmp2];
|
|
}
|
|
} else {
|
|
const mentionCounts = tmp3.mentionCounts;
|
|
delete tmp[tmp3];
|
|
}
|
|
});
|
|
tmp3.unreadByType[constants.CHANNEL] = c2;
|
|
if (tmp3.unreadByType[constants.CHANNEL] !== tmp2.unreadByType[constants.CHANNEL]) {
|
|
if (!tmp3.unreadByType[constants.CHANNEL]) {
|
|
let channel = store.getChannel(tmp2.unreadChannelId);
|
|
if (null != channel) {
|
|
if (!items.includes(channel.id)) {
|
|
if (store2.hasUnread(channel.id)) {
|
|
if (isCountableChannel(channel)) {
|
|
if (null != tmp) {
|
|
set.add(tmp);
|
|
}
|
|
tmp3.unreadByType[constants.CHANNEL] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return recountGuild(tmp);
|
|
}
|
|
}
|
|
return aggregateGuildState(tmp, tmp3, tmp2);
|
|
}
|
|
function updateNonChannel(guild_id, GUILD_EVENT) {
|
|
if (null != guild_id) {
|
|
const tmp2 = getOrCreateGuildState(guild_id);
|
|
const tmp4 = createNewStateFrom(guild_id, tmp2);
|
|
tmp4.unreadByType[constants.GUILD_EVENT] = isNonChannelUnread(guild_id, GUILD_EVENT);
|
|
return aggregateGuildState(guild_id, tmp4, tmp2);
|
|
}
|
|
}
|
|
function recountGuild(guildId) {
|
|
let isMentionLowImportance;
|
|
let mentionCount;
|
|
let tmp17;
|
|
let tmp = sanitizeGuildId(guildId);
|
|
const tmp2 = createGuildState(tmp);
|
|
if (null == tmp) {
|
|
const mutablePrivateChannels = store.getMutablePrivateChannels();
|
|
for (const key10126 in mutablePrivateChannels) {
|
|
let tmp87 = key10126;
|
|
let tmp88 = mutablePrivateChannels[key10126];
|
|
let tmp89 = store2;
|
|
mentionCount = store2.getMentionCount(key10126);
|
|
let tmp67 = mentionCount > 0;
|
|
if (tmp67) {
|
|
let tmp66 = isCountableChannel;
|
|
tmp67 = isCountableChannel(tmp88, mentionCount);
|
|
}
|
|
if (!tmp67) {
|
|
continue;
|
|
} else {
|
|
tmp2.highImportanceMentionCount = tmp2.highImportanceMentionCount + mentionCount;
|
|
let obj = { count: mentionCount, isMentionLowImportance: false };
|
|
tmp2.mentionCounts[tmp88.id] = obj;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
} else {
|
|
const isMutedResult = store3.isMuted(tmp);
|
|
if (isMutedResult) {
|
|
if (false === arg1) {
|
|
return false;
|
|
}
|
|
}
|
|
const mutedChannels = store3.getMutedChannels(tmp);
|
|
const channelOverrides = store3.getChannelOverrides(tmp);
|
|
let obj1 = require(5761) /* useOptInEnabledForGuild */;
|
|
const result = obj1.isOptInEnabledForGuild(tmp);
|
|
const mutableBasicGuildChannelsForGuild = store.getMutableBasicGuildChannelsForGuild(tmp);
|
|
for (const key10030 in mutableBasicGuildChannelsForGuild) {
|
|
let tmp81 = key10030;
|
|
let tmp82 = mutableBasicGuildChannelsForGuild[key10030];
|
|
let hasItem = isMutedResult;
|
|
if (!isMutedResult) {
|
|
hasItem = mutedChannels.has(key10030);
|
|
}
|
|
if (!hasItem) {
|
|
let hasItem1 = null != tmp82.parent_id;
|
|
if (hasItem1) {
|
|
hasItem1 = mutedChannels.has(tmp82.parent_id);
|
|
}
|
|
hasItem = hasItem1;
|
|
}
|
|
let tmp16 = constants;
|
|
tmp17 = tmp2.unreadByType[constants.CHANNEL];
|
|
let tmp18 = store2;
|
|
let tmp19 = store2;
|
|
let tmp20 = tmp82;
|
|
let tmp21 = result;
|
|
let tmp22 = channelOverrides;
|
|
let tmp23 = hasItem;
|
|
let tmp24 = tmp17;
|
|
let guildChannelUnreadState = store2.getGuildChannelUnreadState(tmp82, result, channelOverrides, hasItem, tmp17);
|
|
({ mentionCount, isMentionLowImportance } = guildChannelUnreadState);
|
|
let tmp27 = mentionCount > 0;
|
|
if (tmp27) {
|
|
tmp17 = !tmp17;
|
|
if (tmp17) {
|
|
let tmp28 = !hasItem;
|
|
if (!tmp28) {
|
|
tmp28 = tmp27;
|
|
}
|
|
tmp17 = tmp28;
|
|
}
|
|
if (tmp17) {
|
|
tmp17 = tmp26;
|
|
}
|
|
if (tmp17) {
|
|
let tmp30 = computeIsCountableGuildChannel;
|
|
let tmp31 = tmp17;
|
|
if (!computeIsCountableGuildChannel(tmp82, mentionCount, result)) {
|
|
continue;
|
|
} else {
|
|
if (tmp17) {
|
|
let tmp32 = constants;
|
|
tmp2.unreadByType[constants.CHANNEL] = true;
|
|
tmp2.unreadChannelId = key10030;
|
|
}
|
|
let tmp33 = tmp17;
|
|
if (!tmp27) {
|
|
continue;
|
|
} else {
|
|
if (isMentionLowImportance) {
|
|
tmp2.lowImportanceMentionCount = tmp2.lowImportanceMentionCount + mentionCount;
|
|
} else {
|
|
tmp2.highImportanceMentionCount = tmp2.highImportanceMentionCount + mentionCount;
|
|
}
|
|
obj = { count: mentionCount, isMentionLowImportance };
|
|
tmp2.mentionCounts[tmp82.id] = obj;
|
|
let tmp34 = tmp17;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
} else {
|
|
let tmp29 = tmp17;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
activeJoinedThreadsForGuild = activeJoinedThreadsForGuild.getActiveJoinedThreadsForGuild(tmp);
|
|
const keys = Object.keys();
|
|
if (keys !== undefined) {
|
|
while (keys[tmp17] !== undefined) {
|
|
let tmp83 = tmp45;
|
|
let tmp55 = tmp38;
|
|
let tmp56 = tmp39;
|
|
let tmp57 = tmp40;
|
|
let keys1 = Object.keys();
|
|
if (keys1 === undefined) {
|
|
continue;
|
|
} else {
|
|
tmp38 = tmp55;
|
|
tmp39 = tmp56;
|
|
tmp40 = tmp57;
|
|
let tmp46 = keys1[tmp13];
|
|
while (tmp46 !== undefined) {
|
|
let tmp85 = tmp46;
|
|
let tmp86 = constants;
|
|
let isMutedResult1 = tmp2.unreadByType[constants.CHANNEL];
|
|
if (!isMutedResult1) {
|
|
let tmp47 = store2;
|
|
isMutedResult1 = !store2.hasUnread(tmp46);
|
|
}
|
|
if (!isMutedResult1) {
|
|
let tmp49 = closure_11;
|
|
isMutedResult1 = closure_11.isMuted(tmp46);
|
|
}
|
|
if (!isMutedResult1) {
|
|
isMutedResult1 = isMutedResult;
|
|
}
|
|
if (!isMutedResult1) {
|
|
let tmp50 = constants;
|
|
tmp2.unreadByType[constants.CHANNEL] = true;
|
|
tmp2.unreadChannelId = tmp46;
|
|
}
|
|
let tmp51 = store2;
|
|
let mentionCount1 = store2.getMentionCount(tmp46);
|
|
let tmp53 = store2;
|
|
isMentionLowImportance = store2.getIsMentionLowImportance(tmp46);
|
|
tmp55 = tmp46;
|
|
tmp56 = mentionCount1;
|
|
tmp57 = isMentionLowImportance;
|
|
if (mentionCount1 <= 0) {
|
|
continue;
|
|
} else {
|
|
if (isMentionLowImportance) {
|
|
tmp2.lowImportanceMentionCount = tmp2.lowImportanceMentionCount + mentionCount1;
|
|
} else {
|
|
tmp2.highImportanceMentionCount = tmp2.highImportanceMentionCount + mentionCount1;
|
|
}
|
|
obj1 = { count: mentionCount1, isMentionLowImportance };
|
|
tmp2.mentionCounts[tmp46] = obj1;
|
|
tmp55 = tmp46;
|
|
tmp56 = mentionCount1;
|
|
tmp57 = isMentionLowImportance;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
let tmp59 = !tmp2.unreadByType[constants.GUILD_EVENT];
|
|
if (tmp59) {
|
|
tmp59 = isNonChannelUnread(tmp, constants.GUILD_EVENT);
|
|
}
|
|
if (tmp59) {
|
|
tmp2.unreadByType[constants.GUILD_EVENT] = true;
|
|
}
|
|
}
|
|
updateGuildUnread(tmp2);
|
|
const tmp69 = getOrCreateGuildState(tmp);
|
|
let flag4 = tmp2.unread !== tmp69.unread || tmp2.highImportanceMentionCount !== tmp69.highImportanceMentionCount || tmp2.lowImportanceMentionCount !== tmp69.lowImportanceMentionCount;
|
|
if (flag4) {
|
|
let tmp71 = tmp;
|
|
if (null == tmp) {
|
|
tmp71 = NULL_STRING_GUILD_ID;
|
|
}
|
|
closure_27[tmp71] = tmp2;
|
|
if (null != tmp) {
|
|
if (tmp2.unread) {
|
|
obj6.add(tmp);
|
|
} else {
|
|
obj6.delete(tmp);
|
|
}
|
|
}
|
|
closure_29 = closure_29 + 1;
|
|
if (null == tmp) {
|
|
tmp = NULL_STRING_GUILD_ID;
|
|
}
|
|
updateGuildUnreadSentinel(tmp);
|
|
updateNotificationCenterMentions(tmp2, tmp69);
|
|
flag4 = true;
|
|
const tmp70 = closure_27;
|
|
const tmp75 = updateGuildUnreadSentinel;
|
|
}
|
|
return flag4;
|
|
}
|
|
function handleOverlayInitialize(guilds) {
|
|
guilds = guilds.guilds;
|
|
let closure_27 = {};
|
|
let num = 0;
|
|
let c29 = 0;
|
|
const set = new Set();
|
|
recountGuild(null);
|
|
if (0 < guilds.length) {
|
|
do {
|
|
let tmp3 = guilds[num];
|
|
if (null != tmp3) {
|
|
let tmp4 = recountGuild;
|
|
let tmp5 = recountGuild(tmp3.properties.id);
|
|
}
|
|
num = num + 1;
|
|
} while (num < length);
|
|
}
|
|
}
|
|
function handleConnectionOpen(readState) {
|
|
let iter2;
|
|
readState = readState.readState;
|
|
let closure_27 = {};
|
|
let c29 = 0;
|
|
const set = new Set();
|
|
const set1 = new Set();
|
|
if (readState.entries.length < 500) {
|
|
const entries = readState.entries;
|
|
const item = entries.forEach((mention_count) => {
|
|
let tmp = null != mention_count.mention_count;
|
|
if (tmp) {
|
|
tmp = mention_count.mention_count > 0;
|
|
}
|
|
if (tmp) {
|
|
if (null != mention_count.read_state_type) {
|
|
if (mention_count.read_state_type !== outer1_24.CHANNEL) {
|
|
set1.add(mention_count.id);
|
|
}
|
|
}
|
|
const channel = outer1_16.getChannel(mention_count.id);
|
|
let guild_id;
|
|
if (null != channel) {
|
|
guild_id = channel.guild_id;
|
|
}
|
|
set1.add(guild_id);
|
|
}
|
|
});
|
|
}
|
|
recountGuild(null);
|
|
const tmp5 = _createForOfIteratorHelperLoose(readState.guilds);
|
|
let iter = tmp5();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
let hasItem;
|
|
let tmp6 = recountGuild;
|
|
if (tmp2) {
|
|
hasItem = set1.has(value.id);
|
|
}
|
|
let tmp6Result = tmp6(value.id, hasItem);
|
|
iter2 = tmp5();
|
|
iter = iter2;
|
|
} while (!iter2.done);
|
|
}
|
|
}
|
|
function recomputeAllGuilds() {
|
|
let length;
|
|
let closure_27 = {};
|
|
const set = new Set();
|
|
recountGuild(null);
|
|
const values = Object.values(guildIds.getGuildIds());
|
|
let num = 0;
|
|
if (0 < values.length) {
|
|
do {
|
|
let tmp3 = recountGuild;
|
|
let tmp4 = recountGuild(values[num]);
|
|
num = num + 1;
|
|
length = values.length;
|
|
} while (num < length);
|
|
}
|
|
}
|
|
function handleGuildCreate(guild) {
|
|
return recountGuild(guild.guild.id);
|
|
}
|
|
function handleGuildDelete(guild) {
|
|
guild = guild.guild;
|
|
let flag = null != dependencyMap[guild.id];
|
|
if (flag) {
|
|
const id = guild.id;
|
|
delete tmp2[tmp];
|
|
set.delete(guild.id);
|
|
closure_29 = closure_29 + 1;
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
function handleChannelDelete(channel) {
|
|
channel = channel.channel;
|
|
const items = [channel.id];
|
|
return recountChannels(channel.guild_id, items);
|
|
}
|
|
function handleWindowFocus() {
|
|
const channel = store.getChannel(channelId.getChannelId());
|
|
let tmp = null != channel;
|
|
if (tmp) {
|
|
const items = [channel.id];
|
|
tmp = recountChannels(channel.getGuildId(), items);
|
|
}
|
|
return tmp;
|
|
}
|
|
function handleGuildMemberUpdate(user) {
|
|
let tmp = user.user.id === id.getId();
|
|
if (tmp) {
|
|
tmp = recountGuild(user.guildId);
|
|
}
|
|
return tmp;
|
|
}
|
|
function handleGenericUpdate(channelId) {
|
|
const channel = store.getChannel(channelId.channelId);
|
|
let tmp = null != channel;
|
|
if (tmp) {
|
|
const items = [channel.id];
|
|
tmp = recountChannels(channel.getGuildId(), items);
|
|
}
|
|
return tmp;
|
|
}
|
|
function handleMessageCreate(channelId) {
|
|
channelId = channelId.channelId;
|
|
const channel = store.getChannel(channelId);
|
|
if (null == channel) {
|
|
return false;
|
|
} else {
|
|
if (null != channel.guild_id) {
|
|
if (channel.isThread()) {
|
|
let isMutedResult = !closure_11.hasJoined(channel.id);
|
|
if (!isMutedResult) {
|
|
isMutedResult = closure_11.isMuted(channel.id);
|
|
}
|
|
let result = isMutedResult;
|
|
} else {
|
|
result = store3.isGuildOrCategoryOrChannelMuted(channel.guild_id, channel.id);
|
|
}
|
|
if (result) {
|
|
if (0 === store2.getMentionCount(channelId)) {
|
|
return false;
|
|
}
|
|
}
|
|
const tmp10 = getOrCreateGuildState(channel.guild_id);
|
|
}
|
|
const items = [channel.id];
|
|
return recountChannels(channel.getGuildId(), items);
|
|
}
|
|
}
|
|
function handleChannelSelect(arg0) {
|
|
let channelId;
|
|
let guildId;
|
|
({ channelId, guildId } = arg0);
|
|
let tmp = !require(1841) /* isFavoritesGuildId */.isFavoritesGuildId(guildId);
|
|
if (tmp) {
|
|
let tmp3 = null != channelId;
|
|
if (tmp3) {
|
|
const items = [channelId];
|
|
tmp3 = recountChannels(guildId, items);
|
|
}
|
|
tmp = tmp3;
|
|
}
|
|
return tmp;
|
|
}
|
|
function handleChannelUpdate(channel) {
|
|
channel = channel.channel;
|
|
const items = [channel.id];
|
|
return recountChannels(channel.getGuildId(), items);
|
|
}
|
|
function handleChannelUpdates(channels) {
|
|
const obj = importDefault(22)(channels.channels);
|
|
return importDefault(22)(channels.channels).groupBy((getGuildId) => getGuildId.getGuildId()).reduce((arg0, arr) => outer1_46(arg2, arr.map((id) => id.id)) || arg0, false);
|
|
}
|
|
function handleBulkAck(channels) {
|
|
const mapped = importDefault(22)(channels.channels).map((channelId) => channelId.channelId);
|
|
const found = mapped.filter((channelId) => null != outer1_16.getChannel(channelId));
|
|
const arr = importDefault(22)(channels.channels);
|
|
return found.groupBy((channelId) => {
|
|
const channel = outer1_16.getChannel(channelId);
|
|
let guildId;
|
|
if (null != channel) {
|
|
guildId = channel.getGuildId();
|
|
}
|
|
return guildId;
|
|
}).reduce((arg0, arg1, arg2) => outer1_46(arg2, arg1) || arg0, false);
|
|
}
|
|
function handleThreadUpdate(channel) {
|
|
channel = channel.channel;
|
|
const items = [, ];
|
|
({ id: arr[0], parent_id: arr[1] } = channel);
|
|
return recountChannels(channel.getGuildId(), items);
|
|
}
|
|
function handleGuildEventUpdate(guildScheduledEvent) {
|
|
return updateNonChannel(guildScheduledEvent.guildScheduledEvent.guild_id, constants.GUILD_EVENT);
|
|
}
|
|
function handleGuildEventDelete(guildScheduledEvent) {
|
|
return updateNonChannel(guildScheduledEvent.guildScheduledEvent.guild_id, constants.GUILD_EVENT);
|
|
}
|
|
function handleGuildFeatureAck(id) {
|
|
return updateNonChannel(id.id, id.ackType);
|
|
}
|
|
function handleThreadMemberUpdate(id) {
|
|
const items = [id.id];
|
|
return recountChannels(id.guildId, items);
|
|
}
|
|
function handleThreadMembersUpdate(id) {
|
|
let result = require(3766) /* doesThreadMembersActionAffectMe */.doesThreadMembersActionAffectMe(id);
|
|
if (result) {
|
|
const items = [id.id];
|
|
result = recountChannels(id.guildId, items);
|
|
}
|
|
return result;
|
|
}
|
|
function handleThreadListSync(threads) {
|
|
threads = threads.threads;
|
|
const found = threads.filter((id) => outer1_11.hasJoined(id.id));
|
|
return recountChannels(threads.guildId, found.map((id) => id.id));
|
|
}
|
|
function handlePassiveUpdateV2(channels) {
|
|
let guildId;
|
|
let tmp = channels.channels.length > 0;
|
|
if (tmp) {
|
|
({ channels, guildId } = channels);
|
|
tmp = recountChannels(guildId, channels.map((id) => id.id));
|
|
}
|
|
return tmp;
|
|
}
|
|
function handleMarkGuildAsRead(guildId) {
|
|
return recountGuild(guildId.guildId);
|
|
}
|
|
function handleGuildUpdate(guildId) {
|
|
return recountGuild(guildId.guildId);
|
|
}
|
|
function handleUserGuildSettingsFullUpdate(userGuildSettings) {
|
|
userGuildSettings = userGuildSettings.userGuildSettings;
|
|
const set = new Set(userGuildSettings.map((guild_id) => {
|
|
guild_id = guild_id.guild_id;
|
|
if (null == guild_id) {
|
|
guild_id = outer1_26;
|
|
}
|
|
return guild_id;
|
|
}));
|
|
const keys = importDefault(21).keys(closure_27);
|
|
return keys.reduce((arg0, arg1) => {
|
|
let hasItem = set.has(arg1);
|
|
if (hasItem) {
|
|
hasItem = outer1_48(arg1);
|
|
}
|
|
if (!hasItem) {
|
|
hasItem = arg0;
|
|
}
|
|
return hasItem;
|
|
}, false);
|
|
}
|
|
function handleClearNotifCenterGuildMentions() {
|
|
for (const key10003 in closure_27) {
|
|
let tmp = key10003;
|
|
let tmp2 = dependencyMap;
|
|
dependencyMap[key10003].ncMentionCount = 0;
|
|
continue;
|
|
}
|
|
}
|
|
function handleUserGuildSettingsUpdate(guildId, arg1) {
|
|
return recountGuild(guildId.guildId);
|
|
}
|
|
function handleRecentMentionsSuccess(messages) {
|
|
messages = messages.messages;
|
|
const item = new Set(messages.map((channel_id) => channel_id.channel_id)).forEach((channelId) => {
|
|
const channel = outer1_16.getChannel(channelId);
|
|
if (null != channel) {
|
|
const items = [channelId];
|
|
outer1_46(channel.getGuildId(), items);
|
|
}
|
|
});
|
|
}
|
|
({ getBasicAccessPermissions: closure_12, isGuildVocalChannelType: closure_13, isThread: closure_14 } = _callSuper);
|
|
({ ReadStateTypes: closure_24, UnreadSetting: closure_25 } = ReadStateTypes);
|
|
let closure_27 = {};
|
|
let set = new Set();
|
|
let c29 = 0;
|
|
tmp6.displayName = "GuildReadStateStore";
|
|
tmp6.LATEST_SNAPSHOT_VERSION = 1;
|
|
tmp6 = new tmp6();
|
|
let result = set.fileFinishedImporting("stores/GuildReadStateStore.tsx");
|
|
|
|
export default tmp6;
|