2845 lines
91 KiB
JavaScript
2845 lines
91 KiB
JavaScript
// Module ID: 6749
|
|
// Function ID: 52658
|
|
// Name: _superPropGet
|
|
// Dependencies: [6, 7, 15, 17, 18, 1316, 1194, 1348, 1907, 1917, 1838, 4138, 4317, 653, 664, 5655, 686, 5338, 21, 566, 2, 1838, 3756, 4317, 1849, 653, 566, 2, 5356, 5355, 2, 6, 7, 15, 17, 18, 57, 3809, 1196, 1849, 6759, 1387, 21, 6760]
|
|
|
|
// Module 6749 (_superPropGet)
|
|
import _classCallCheck from "_classCallCheck";
|
|
import _defineProperties from "_defineProperties";
|
|
import _possibleConstructorReturn from "_possibleConstructorReturn";
|
|
import _getPrototypeOf from "_getPrototypeOf";
|
|
import _inherits from "_inherits";
|
|
import _isNativeReflectConstruct from "_isNativeReflectConstruct";
|
|
import closure_9 from "_isNativeReflectConstruct";
|
|
import closure_10 from "_isNativeReflectConstruct";
|
|
import closure_11 from "_isNativeReflectConstruct";
|
|
import closure_12 from "_isNativeReflectConstruct";
|
|
import closure_13 from "_createForOfIteratorHelperLoose";
|
|
import closure_14 from "_isNativeReflectConstruct";
|
|
import closure_15 from "_isNativeReflectConstruct";
|
|
import ME from "ME";
|
|
import module_664 from "module_664";
|
|
import SidebarType from "SidebarType";
|
|
import dispatcher from "dispatcher";
|
|
import _createForOfIteratorHelperLoose from "_createForOfIteratorHelperLoose";
|
|
import DISCORD_EPOCH from "DISCORD_EPOCH";
|
|
import initialize from "initialize";
|
|
import closure_26 from "keys";
|
|
import closure_27 from "_createForOfIteratorHelperLoose";
|
|
import closure_28 from "_isNativeReflectConstruct";
|
|
import closure_29 from "_isNativeReflectConstruct";
|
|
import closure_30 from "_isNativeReflectConstruct";
|
|
import closure_31 from "ME";
|
|
import closure_32 from "initialize";
|
|
import closure_33 from "keys";
|
|
import closure_34 from "_isNativeReflectConstruct";
|
|
import { ChannelListGuildActionRow } from "useDesignToggle";
|
|
import keys from "keys";
|
|
import { ChannelFlags } from "_classCallCheck";
|
|
import { Permissions } from "_defineProperties";
|
|
import maybeFetchCollectiblesForInvoices from "maybeFetchCollectiblesForInvoices";
|
|
|
|
function _superPropGet(arg0, arg1, arg2, arg3) {
|
|
arg1 = arg2;
|
|
let prototype = arg0;
|
|
if (1) {
|
|
prototype = arg0.prototype;
|
|
}
|
|
const tmpResult = _classCallCheck(_possibleConstructorReturn(prototype), arg1, arg2);
|
|
const importDefault = tmpResult;
|
|
let fn = tmpResult;
|
|
if (2) {
|
|
fn = tmpResult;
|
|
if ("function" === typeof tmpResult) {
|
|
fn = (arg0) => tmpResult.apply(arg2, arg0);
|
|
}
|
|
}
|
|
return fn;
|
|
}
|
|
function _callSuper(arg0, arg1, arg2) {
|
|
let items = arg2;
|
|
const obj = callback(arg1);
|
|
if (_isNativeReflectConstruct()) {
|
|
if (!items) {
|
|
items = [];
|
|
}
|
|
let constructResult = Reflect.construct(obj, items, callback(arg0).constructor);
|
|
} else {
|
|
constructResult = obj.apply(arg0, items);
|
|
}
|
|
return _defineProperties(arg0, constructResult);
|
|
}
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function _createForOfIteratorHelperLoose(@@iterator) {
|
|
let arg1 = Symbol_iterator;
|
|
@@iterator = "undefined" !== typeof Symbol;
|
|
if (Symbol_iterator) {
|
|
const _Symbol = Symbol;
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (!Symbol_iterator) {
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (Symbol_iterator) {
|
|
const iter = Symbol_iterator.call(Symbol_iterator);
|
|
const next = iter.next;
|
|
return next.bind(iter);
|
|
} else {
|
|
const _Array = Array;
|
|
let tmp = Symbol_iterator;
|
|
if (!Array.isArray(Symbol_iterator)) {
|
|
let tmp2;
|
|
if (Symbol_iterator) {
|
|
if ("string" === typeof Symbol_iterator) {
|
|
tmp2 = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const toString = {}.toString;
|
|
const substr = toString.call(Symbol_iterator).slice(8, -1);
|
|
let name = substr;
|
|
if (tmp3) {
|
|
name = Symbol_iterator.constructor.name;
|
|
}
|
|
if ("Map" !== name) {
|
|
if ("Set" !== name) {
|
|
if ("Arguments" === name) {
|
|
let arr = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
|
|
}
|
|
}
|
|
tmp2 = arr;
|
|
}
|
|
const _Array2 = Array;
|
|
arr = Array.from(Symbol_iterator);
|
|
const callResult = toString.call(Symbol_iterator);
|
|
const tmp3 = "Object" === substr && Symbol_iterator.constructor;
|
|
}
|
|
}
|
|
tmp = tmp2;
|
|
if (!tmp2) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
throw typeError;
|
|
}
|
|
}
|
|
if (tmp) {
|
|
arg1 = tmp;
|
|
}
|
|
let closure_1 = 0;
|
|
return () => {
|
|
if (closure_1 >= tmp.length) {
|
|
let obj = { done: true };
|
|
} else {
|
|
obj = { done: false };
|
|
closure_1 = tmp3 + 1;
|
|
obj.value = tmp[+closure_1];
|
|
}
|
|
return obj;
|
|
};
|
|
}
|
|
}
|
|
function _arrayLikeToArray(arg0, arg1) {
|
|
let length;
|
|
if (tmp) {
|
|
length = arg0.length;
|
|
}
|
|
const ArrayResult = Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
ArrayResult[num] = arg0[num];
|
|
}
|
|
return ArrayResult;
|
|
}
|
|
function _computeSubtitle(type) {
|
|
type = type.type;
|
|
if (constants.GUILD_VOICE === type) {
|
|
const activeEventByChannel = store.getActiveEventByChannel(type.id);
|
|
if (null != activeEventByChannel) {
|
|
let obj = { type: "event", name: activeEventByChannel.name };
|
|
return obj;
|
|
} else {
|
|
if (arg2) {
|
|
if (arg1) {
|
|
let obj1 = arg1(dependencyMap[42]);
|
|
if (obj1.hasStream(tmp18)) {
|
|
obj = { type: "go-live" };
|
|
return obj;
|
|
}
|
|
}
|
|
}
|
|
const channelStatus = channelStatus.getChannelStatus(type);
|
|
if (null != channelStatus) {
|
|
if (channelStatus.length > 0) {
|
|
obj1 = { type: "voice", text: channelStatus };
|
|
return obj1;
|
|
}
|
|
}
|
|
const embeddedActivitiesForChannel = embeddedActivitiesForChannel.getEmbeddedActivitiesForChannel(type.id);
|
|
const mapped = embeddedActivitiesForChannel.map((applicationId) => {
|
|
const application = application.getApplication(applicationId.applicationId);
|
|
let name;
|
|
if (null != application) {
|
|
name = application.name;
|
|
}
|
|
return name;
|
|
});
|
|
const found = mapped.filter(arg1(dependencyMap[40]).isNotNullish);
|
|
let tmp16 = null;
|
|
if (found.length > 0) {
|
|
const obj2 = { type: "embedded-activities", name: found.join(", ") };
|
|
tmp16 = obj2;
|
|
}
|
|
return tmp16;
|
|
}
|
|
} else if (constants.GUILD_STAGE_VOICE === type) {
|
|
const activeEventByChannel1 = store.getActiveEventByChannel(type.id);
|
|
let tmp5 = null;
|
|
if (null != activeEventByChannel1) {
|
|
obj = { type: "event", name: activeEventByChannel1.name };
|
|
tmp5 = obj;
|
|
}
|
|
return tmp5;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
function computeThreadIds(id, activeJoinedUnreadThreadsForParent, closure_2, _classCallCheck, closure_1) {
|
|
let arr = closure_2;
|
|
let tmp = null != closure_2;
|
|
if (tmp) {
|
|
let tmp2 = arr.id === id.id;
|
|
if (!tmp2) {
|
|
tmp2 = _classCallCheck === id.id;
|
|
}
|
|
tmp = tmp2;
|
|
}
|
|
if (set.has(id.type)) {
|
|
const _Object = Object;
|
|
const obj2 = importDefault(dependencyMap[33]);
|
|
const mapped = importDefault(dependencyMap[33]).sortBy(Object.values(activeJoinedUnreadThreadsForParent), (joinTimestamp) => -joinTimestamp.joinTimestamp).map((channel) => channel.channel.id);
|
|
if (tmp) {
|
|
return mapped;
|
|
} else if (tmp4) {
|
|
let found = mapped;
|
|
if (!(arr.id in activeJoinedUnreadThreadsForParent)) {
|
|
arr = mapped.unshift(arr.id);
|
|
found = mapped;
|
|
}
|
|
} else {
|
|
found = mapped;
|
|
if (closure_1) {
|
|
found = mapped.filter((id) => {
|
|
let tmp = !muted.isMuted(id);
|
|
if (!tmp) {
|
|
tmp = mentionCount.getMentionCount(id) > 0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
const sortByResult = importDefault(dependencyMap[33]).sortBy(Object.values(activeJoinedUnreadThreadsForParent), (joinTimestamp) => -joinTimestamp.joinTimestamp);
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
function shouldShowInFavorites(favoriteChannelIds, id) {
|
|
favoriteChannelIds = favoriteChannelIds.favoriteChannelIds;
|
|
return favoriteChannelIds.has(id.id);
|
|
}
|
|
function shouldAlwaysShowInRecents(id, selectedChannel) {
|
|
selectedChannel = selectedChannel.selectedChannel;
|
|
if (store3.getMentionCount(id.id) > 0) {
|
|
return true;
|
|
} else {
|
|
for (const key10009 in tmp[arg0.id]) {
|
|
let tmp6 = key10009;
|
|
let tmp7 = closure_29;
|
|
if (closure_29.getMentionCount(key10009) <= 0) {
|
|
continue;
|
|
} else {
|
|
let flag = true;
|
|
return true;
|
|
}
|
|
}
|
|
if (null != selectedChannel) {
|
|
if (selectedChannel.id === id.id) {
|
|
return false;
|
|
} else if (selectedChannel.isThread()) {
|
|
if (selectedChannel.parent_id === id.id) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
const newChannelIds = store2.getNewChannelIds(id.category.guild.id);
|
|
let hasItem = !tmp4;
|
|
if (newChannelIds.size <= 2) {
|
|
hasItem = newChannelIds.has(id.id);
|
|
}
|
|
return hasItem;
|
|
}
|
|
}
|
|
function shouldShowInRecents(optInEnabled, type) {
|
|
if (type.type === constants.GUILD_DIRECTORY) {
|
|
return false;
|
|
} else if (optInEnabled.optInEnabled) {
|
|
const optedInChannels = optInEnabled.optedInChannels;
|
|
if (optedInChannels.has(type.id)) {
|
|
return false;
|
|
} else if (type.isThread()) {
|
|
return false;
|
|
} else {
|
|
if (null != type.parent_id) {
|
|
const optedInChannels2 = optInEnabled.optedInChannels;
|
|
if (optedInChannels2.has(type.parent_id)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (optInEnabled.hideResourceChannels) {
|
|
if (type.hasFlag(ChannelFlags.IS_GUILD_RESOURCE_CHANNEL)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (type.isGuildVocal()) {
|
|
if (voiceCategoryCollapsed.isVoiceCategoryCollapsed(optInEnabled.id)) {
|
|
if (obj.some(voiceStatesForChannel.getVoiceStatesForChannel(type.id))) {
|
|
return false;
|
|
}
|
|
const obj = importDefault(dependencyMap[33]);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
if (store3.getMentionCount(type.id) > 0) {
|
|
return true;
|
|
} else {
|
|
for (const key10050 in tmp[arg1.id]) {
|
|
let tmp17 = key10050;
|
|
let tmp18 = closure_29;
|
|
if (closure_29.getMentionCount(key10050) > 0) {
|
|
let flag5 = true;
|
|
return true;
|
|
} else {
|
|
let tmp9 = closure_29;
|
|
if (closure_29.hasUnread(key10050)) {
|
|
let flag4 = true;
|
|
return true;
|
|
} else {
|
|
let tmp10 = closure_29;
|
|
if (!closure_29.hasRecentlyVisitedAndRead(key10050)) {
|
|
continue;
|
|
} else {
|
|
let flag3 = true;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const mutedChannelIds = optInEnabled.mutedChannelIds;
|
|
if (!mutedChannelIds.has(type.id)) {
|
|
if (null != type.parent_id) {
|
|
const mutedChannelIds2 = optInEnabled.mutedChannelIds;
|
|
}
|
|
const newChannelIds = store2.getNewChannelIds(optInEnabled.id);
|
|
const _Array = Array;
|
|
const sorted = Array.from(newChannelIds).sort((arg0, arg1) => callback(closure_2[41]).compare(arg1, arg0));
|
|
let hasItem = newChannelIds.has(type.id);
|
|
if (hasItem) {
|
|
hasItem = sorted.indexOf(type.id) < 2;
|
|
}
|
|
let result = !tmp14;
|
|
if (!hasItem) {
|
|
result = store3.hasRecentlyVisitedAndRead(type.id);
|
|
}
|
|
return result;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
({ ChannelRecordBase: closure_20, isGuildReadableType: closure_21, isThread: closure_22, THREADED_CHANNEL_TYPES: closure_23 } = _createForOfIteratorHelperLoose);
|
|
({ ChannelTypes: closure_36, GuildFeatures: closure_37 } = keys);
|
|
let closure_40 = { CannotShow: 1, [1]: "CannotShow", DoNotShow: 2, [2]: "DoNotShow", WouldShowIfUncollapsed: 3, [3]: "WouldShowIfUncollapsed", Show: 4, [4]: "Show" };
|
|
const obj = { CHANNEL_NOTICES: 0, [0]: "CHANNEL_NOTICES", GUILD_ACTIONS: 1, [1]: "GUILD_ACTIONS", FAVORITES: 2, [2]: "FAVORITES", RECENTS: 3, [3]: "RECENTS", UNCATEGORIZED_CHANNELS: 4, [4]: "UNCATEGORIZED_CHANNELS", FIRST_NAMED_CATEGORY: 5, [5]: "FIRST_NAMED_CATEGORY" };
|
|
const CHANNEL_NOTICES = obj.CHANNEL_NOTICES;
|
|
const GUILD_ACTIONS = obj.GUILD_ACTIONS;
|
|
const FAVORITES = obj.FAVORITES;
|
|
const RECENTS = obj.RECENTS;
|
|
const UNCATEGORIZED_CHANNELS = obj.UNCATEGORIZED_CHANNELS;
|
|
const FIRST_NAMED_CATEGORY = obj.FIRST_NAMED_CATEGORY;
|
|
const items = [String(ChannelListGuildActionRow.GUILD_DIRECTORY)];
|
|
const set = new Set(items);
|
|
let closure_48 = () => {
|
|
class ChannelListImpl {
|
|
constructor(arg0, arg1, arg2) {
|
|
self = this;
|
|
tmp = _inherits(this, ChannelListImpl);
|
|
this.id = arg0;
|
|
this.sortedNamedCategories = null;
|
|
this.sections = null;
|
|
this.rows = null;
|
|
this.firstVoiceChannel = undefined;
|
|
this.allChannelsById = null;
|
|
this.version = 0;
|
|
this.hideMutedChannels = closure_31.isGuildCollapsed(this.id);
|
|
this.mutedChannelIds = closure_31.getMutedChannels(this.id);
|
|
optedInChannelsWithPendingUpdates = closure_31.getOptedInChannelsWithPendingUpdates(this.id);
|
|
if (null == optedInChannelsWithPendingUpdates) {
|
|
tmp3 = closure_31;
|
|
optedInChannelsWithPendingUpdates = closure_31.getOptedInChannels(self.id);
|
|
}
|
|
self.optedInChannels = optedInChannelsWithPendingUpdates;
|
|
obj = ChannelListImpl(closure_2[34]);
|
|
self.optInEnabled = obj.isOptInEnabledForGuild(self.id);
|
|
obj2 = ChannelListImpl(closure_2[35]);
|
|
self.hideResourceChannels = obj2.canSeeOnboardingHome(self.id);
|
|
guildFavorites = closure_31.getGuildFavorites(self.id);
|
|
if (null == guildFavorites) {
|
|
guildFavorites = [];
|
|
}
|
|
set = new Set(guildFavorites);
|
|
self.favoriteChannelIds = set;
|
|
self.suggestedFavoriteChannelId = closure_15.getSuggestedChannelId(self.id);
|
|
self.collapsedCategoryIds = DISCORD_EPOCH.getCollapsedCategories();
|
|
mutableGuildChannelsForGuild = initialize.getMutableGuildChannelsForGuild(self.id);
|
|
guild = closure_27.getGuild(self.id);
|
|
tmp8 = null;
|
|
if (null != guild) {
|
|
tmp6 = closure_1;
|
|
tmp9 = closure_2;
|
|
num = 36;
|
|
tmp8 = closure_1(closure_2[36])(guild);
|
|
}
|
|
self.moderatorReportChannelId = tmp8;
|
|
tmp10 = null != guild;
|
|
if (tmp10) {
|
|
tmp6 = closure_1;
|
|
tmp11 = closure_2;
|
|
num2 = 37;
|
|
tmp10 = closure_1(closure_2[37])(guild);
|
|
}
|
|
self.moderatorReportChannelEnabled = tmp10;
|
|
obj = {};
|
|
items = [];
|
|
obj1 = {};
|
|
for (const key10078 in mutableGuildChannelsForGuild) {
|
|
tmp45 = key10078;
|
|
tmp46 = mutableGuildChannelsForGuild[key10078];
|
|
tmp47 = closure_36;
|
|
GUILD_CATEGORY = closure_36.GUILD_CATEGORY;
|
|
if (tmp46.type !== GUILD_CATEGORY) {
|
|
continue;
|
|
} else {
|
|
obj[tmp46.id] = tmp46;
|
|
obj1[tmp46.id] = [];
|
|
// continue
|
|
}
|
|
continue;
|
|
}
|
|
items1 = [];
|
|
items2 = [];
|
|
items3 = [];
|
|
initializationData = self.initializationData;
|
|
for (const key10088 in mutableGuildChannelsForGuild) {
|
|
tmp48 = key10088;
|
|
obj7 = mutableGuildChannelsForGuild[key10088];
|
|
tmp49 = closure_36;
|
|
if (obj7.type === closure_36.GUILD_CATEGORY) {
|
|
continue;
|
|
} else {
|
|
if (obj7.isGameInvitesChannel()) {
|
|
continue;
|
|
} else {
|
|
tmp12 = closure_36;
|
|
if (obj7.type !== closure_36.GUILD_DIRECTORY) {
|
|
tmp16 = closure_72;
|
|
if (closure_72(self, obj7, initializationData)) {
|
|
arr = items1.push(obj7);
|
|
} else {
|
|
tmp17 = closure_36;
|
|
tmp18 = obj7.type !== closure_36.GUILD_VOICE;
|
|
if (!tmp18) {
|
|
} else {
|
|
tmp19 = closure_36;
|
|
tmp18 = obj7.type !== closure_36.GUILD_STAGE_VOICE;
|
|
}
|
|
if (tmp18) {
|
|
} else {
|
|
tmp20 = null != obj7.parent_id;
|
|
if (!tmp20) {
|
|
} else {
|
|
tmp20 = null != obj[obj7.parent_id];
|
|
}
|
|
if (!tmp20) {
|
|
} else {
|
|
arr1 = items2.push(obj[obj7.parent_id]);
|
|
}
|
|
arr2 = items2.push(obj7);
|
|
}
|
|
}
|
|
if (null == obj7.parent_id) {
|
|
} else if (obj7.parent_id in obj1) {
|
|
arr6 = obj1[obj7.parent_id];
|
|
arr3 = arr6.push(obj7);
|
|
// continue
|
|
}
|
|
arr4 = items.push(obj7);
|
|
// continue
|
|
} else {
|
|
hasItem = null == guild;
|
|
if (hasItem) {
|
|
} else {
|
|
features = guild.features;
|
|
tmp14 = closure_37;
|
|
hasItem = features.has(closure_37.HUB);
|
|
}
|
|
if (hasItem) {
|
|
continue;
|
|
} else {
|
|
arr5 = items3.push(obj7);
|
|
// continue
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
self.categories = {};
|
|
for (const key10134 in obj1) {
|
|
tmp50 = key10134;
|
|
tmp51 = closure_50;
|
|
prototype3 = closure_50.prototype;
|
|
tmp52 = new.target;
|
|
tmp53 = new.target;
|
|
tmp54 = self;
|
|
tmp55 = initializationData;
|
|
tmp56 = new closure_50(self, obj[key10134], obj1[key10134], initializationData);
|
|
tmp57 = tmp56;
|
|
self.categories[key10134] = tmp56;
|
|
}
|
|
self.recentsSectionNumber = closure_44;
|
|
self.favoritesSectionNumber = closure_43;
|
|
tmp26 = new closure_49(self, items, initializationData);
|
|
self.noParentCategory = tmp26;
|
|
tmp27 = new closure_51(self, initializationData);
|
|
self.favoritesCategory = tmp27;
|
|
obj5 = ChannelListImpl(closure_2[38]);
|
|
if (obj5.isRecentlyActiveChannelsEnabled()) {
|
|
tmp35 = closure_52;
|
|
prototype2 = closure_52.prototype;
|
|
tmp36 = new.target;
|
|
tmp37 = new.target;
|
|
tmp38 = self;
|
|
tmp39 = mutableGuildChannelsForGuild;
|
|
tmp40 = initializationData;
|
|
tmp34 = new closure_52(self, mutableGuildChannelsForGuild, initializationData);
|
|
} else {
|
|
tmp28 = closure_53;
|
|
prototype = closure_53.prototype;
|
|
tmp29 = new.target;
|
|
tmp30 = new.target;
|
|
tmp31 = self;
|
|
tmp32 = items1;
|
|
tmp33 = initializationData;
|
|
tmp34 = new closure_53(self, items1, initializationData);
|
|
}
|
|
self.recentsCategory = tmp34;
|
|
tmp41 = new closure_54(self, items2, obj, initializationData);
|
|
self.voiceChannelsCategory = tmp41;
|
|
tmp42 = new closure_56(arg1, items3.length > 0);
|
|
self.guildActionSection = tmp42;
|
|
tmp43 = new closure_55(arg2);
|
|
self.channelNoticeSection = tmp43;
|
|
tmp44 = closure_1(closure_2[39])(!("null" in self.categories), "somehow a null got into categories");
|
|
obj6 = closure_1(closure_2[33]);
|
|
self.voiceChannelsSectionNumber = closure_46 + obj6.size(self.categories);
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = ChannelListImpl;
|
|
let obj = {
|
|
key: "initializationData",
|
|
get() {
|
|
return { selectedChannel: store2.getChannel(store3.getChannelId()), selectedVoiceChannelId: store3.getVoiceChannelId(), activeJoinedRelevantThreads: store.getActiveJoinedRelevantThreadsForGuild(this.id), activeJoinedUnreadThreads: store.getActiveJoinedUnreadThreadsForGuild(this.id) };
|
|
}
|
|
};
|
|
const items = [obj, , , , , , , , , , , , , , , , , , , , , , , ];
|
|
obj = {
|
|
key: "invalidate",
|
|
value() {
|
|
this.sections = null;
|
|
this.rows = null;
|
|
this.sortedNamedCategories = null;
|
|
this.firstVoiceChannel = undefined;
|
|
this.version = this.version + 1;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "getSortedNamedCategories",
|
|
value() {
|
|
const self = this;
|
|
if (null == this.sortedNamedCategories) {
|
|
const rows = self.getRows();
|
|
}
|
|
return self.sortedNamedCategories;
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "getSortedCategories",
|
|
value() {
|
|
const items = [this.favoritesCategory, this.recentsCategory, this.noParentCategory, ...this.getSortedNamedCategories(), this.voiceChannelsCategory];
|
|
return items;
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "getSections",
|
|
value() {
|
|
let flag = arg0;
|
|
const self = this;
|
|
if (arg0 === undefined) {
|
|
flag = false;
|
|
}
|
|
if (null == self.sections) {
|
|
const rows = self.getRows();
|
|
self.sections = rows.map((arg0) => arg0.length);
|
|
}
|
|
const sections = self.sections;
|
|
if (flag) {
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(sections, 0);
|
|
let tmp = items;
|
|
} else {
|
|
tmp = sections;
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "getRows",
|
|
value() {
|
|
const self = this;
|
|
if (null == this.rows) {
|
|
const _Object = Object;
|
|
self.sortedNamedCategories = callback(closure_2[33]).sortBy(Object.values(self.categories), (record) => record.record.position);
|
|
const items = [, , , , , ];
|
|
({ channelNoticeSection: arr[0], guildActionSection: arr[1], favoritesCategory: arr[2], recentsCategory: arr[3], noParentCategory: arr[4] } = self);
|
|
let arraySpreadResult = HermesBuiltin.arraySpread(self.sortedNamedCategories, 5);
|
|
items[arraySpreadResult] = self.voiceChannelsCategory;
|
|
const sum = arraySpreadResult + 1;
|
|
self.rows = items.map((getRows) => getRows.getRows());
|
|
const items1 = [self.noParentCategory];
|
|
arraySpreadResult = HermesBuiltin.arraySpread(self.sortedNamedCategories, 1);
|
|
let num2 = 0;
|
|
let num = 0;
|
|
if (0 < items1.length) {
|
|
do {
|
|
let obj = items1[num2];
|
|
let sum1 = num + 1;
|
|
obj.position = sum1;
|
|
let tmp2 = closure_66;
|
|
let tmp3 = closure_66(obj.getShownChannelIds());
|
|
let iter = tmp3();
|
|
let tmp4 = sum1;
|
|
num = sum1;
|
|
if (!iter.done) {
|
|
do {
|
|
let sum2 = tmp4 + 1;
|
|
obj.channels[iter.value].position = sum2;
|
|
let iter2 = tmp3();
|
|
tmp4 = sum2;
|
|
iter = iter2;
|
|
num = sum2;
|
|
let done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
num2 = num2 + 1;
|
|
} while (num2 < items1.length);
|
|
}
|
|
const obj2 = callback(closure_2[33]);
|
|
}
|
|
return self.rows;
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "getCategoryFromSection",
|
|
value(arg0) {
|
|
const self = this;
|
|
if (closure_41 === arg0) {
|
|
const _Error2 = Error;
|
|
throw Error("Invalid section. Use getChannelNoticeSection instead");
|
|
} else if (closure_42 === arg0) {
|
|
const _Error = Error;
|
|
throw Error("Invalid section. Use getGuildActionSection instead");
|
|
} else if (closure_43 === arg0) {
|
|
return self.favoritesCategory;
|
|
} else if (closure_45 === arg0) {
|
|
return self.noParentCategory;
|
|
} else if (self.recentsSectionNumber === arg0) {
|
|
return self.recentsCategory;
|
|
} else if (self.voiceChannelsSectionNumber === arg0) {
|
|
return self.voiceChannelsCategory;
|
|
} else {
|
|
return self.getSortedNamedCategories()[arg0 - closure_46];
|
|
}
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "getNamedCategoryFromSection",
|
|
value(arg0) {
|
|
const self = this;
|
|
const diff = arg0 - closure_46;
|
|
let tmp3 = diff >= 0;
|
|
if (tmp3) {
|
|
tmp3 = diff < self.getSortedNamedCategories().length;
|
|
}
|
|
callback(closure_2[39])(tmp3, "invalid section index " + diff);
|
|
return self.getSortedNamedCategories()[diff];
|
|
}
|
|
};
|
|
items[8] = {
|
|
key: "getGuildActionSection",
|
|
value() {
|
|
return this.guildActionSection;
|
|
}
|
|
};
|
|
items[9] = {
|
|
key: "getChannelNoticeSection",
|
|
value() {
|
|
return this.channelNoticeSection;
|
|
}
|
|
};
|
|
items[10] = {
|
|
key: "getChannelFromSectionRow",
|
|
value(recentsSectionNumber) {
|
|
const categoryFromSection = this.getCategoryFromSection(recentsSectionNumber);
|
|
if (null == categoryFromSection) {
|
|
return null;
|
|
} else {
|
|
let tmp3 = null;
|
|
if (null != categoryFromSection.channels[categoryFromSection.getShownChannelIds(categoryFromSection)[arg1]]) {
|
|
const obj = { category: categoryFromSection, channel: tmp2 };
|
|
tmp3 = obj;
|
|
}
|
|
return tmp3;
|
|
}
|
|
}
|
|
};
|
|
items[11] = {
|
|
key: "isPlaceholderRow",
|
|
value(arg0, arg1) {
|
|
const self = this;
|
|
callback(closure_2[39])(arg0 > closure_42, "Invalid section");
|
|
let tmp2 = arg0 !== this.recentsSectionNumber;
|
|
if (tmp2) {
|
|
tmp2 = self.getRows()[arg0][arg1] === "placeholder-channel-id";
|
|
}
|
|
return tmp2;
|
|
}
|
|
};
|
|
items[12] = {
|
|
key: "getFirstVoiceChannel",
|
|
value(arg0) {
|
|
const self = this;
|
|
if (undefined === this.firstVoiceChannel) {
|
|
const favoritesCategory = self.favoritesCategory;
|
|
self.firstVoiceChannel = favoritesCategory.getFirstVoiceChannel(arg0);
|
|
if (null != self.firstVoiceChannel) {
|
|
return self.firstVoiceChannel;
|
|
} else {
|
|
const noParentCategory = self.noParentCategory;
|
|
self.firstVoiceChannel = noParentCategory.getFirstVoiceChannel(arg0);
|
|
if (null != self.firstVoiceChannel) {
|
|
return self.firstVoiceChannel;
|
|
} else {
|
|
const tmp2 = callback3(self.getSortedNamedCategories());
|
|
const iter = tmp2();
|
|
let iter2 = iter;
|
|
if (!iter.done) {
|
|
const value = iter2.value;
|
|
while (null == value.getFirstVoiceChannel(arg0)) {
|
|
let iter3 = tmp2();
|
|
iter2 = iter3;
|
|
}
|
|
self.firstVoiceChannel = value.getFirstVoiceChannel(arg0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return self.firstVoiceChannel;
|
|
}
|
|
};
|
|
items[13] = {
|
|
key: "getSectionRowsFromChannel",
|
|
value(channelId) {
|
|
const self = this;
|
|
let GUILD_DIRECTORY = null;
|
|
if (null != channelId) {
|
|
GUILD_DIRECTORY = channelId;
|
|
if (!set.has(channelId)) {
|
|
const channel = store2.getChannel(channelId);
|
|
GUILD_DIRECTORY = null;
|
|
if (null != channel) {
|
|
GUILD_DIRECTORY = null;
|
|
if (channel.isDirectory()) {
|
|
GUILD_DIRECTORY = constants.GUILD_DIRECTORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (null != GUILD_DIRECTORY) {
|
|
let obj = {};
|
|
const guildActionSection = self.getGuildActionSection();
|
|
const rows = guildActionSection.getRows();
|
|
obj.row = rows.indexOf(GUILD_DIRECTORY);
|
|
obj.section = closure_42;
|
|
const items = [obj];
|
|
return items;
|
|
} else {
|
|
const items1 = [];
|
|
const channel1 = store2.getChannel(channelId);
|
|
let ChannelListImpl = channel1;
|
|
if (null != channel1) {
|
|
if (null != channelId) {
|
|
const isThreadResult = channel1.isThread();
|
|
let tmp7 = channel1;
|
|
if (isThreadResult) {
|
|
const channel2 = store2.getChannel(channel1.parent_id);
|
|
ChannelListImpl = channel2;
|
|
tmp7 = channel2;
|
|
}
|
|
if (null == tmp7) {
|
|
return items1;
|
|
} else {
|
|
const favoritesCategory = self.favoritesCategory;
|
|
const shownChannelIds = favoritesCategory.getShownChannelIds();
|
|
const index = shownChannelIds.indexOf(tmp7.id);
|
|
if (index >= 0) {
|
|
obj = { section: closure_43, row: index };
|
|
items1.push(obj);
|
|
}
|
|
const recentsCategory = self.recentsCategory;
|
|
const shownChannelIds1 = recentsCategory.getShownChannelIds();
|
|
const index1 = shownChannelIds1.indexOf(tmp7.id);
|
|
if (index1 >= 0) {
|
|
const obj1 = { section: self.recentsSectionNumber, row: index1 };
|
|
items1.push(obj1);
|
|
}
|
|
if (tmp7.type === constants2.GUILD_CATEGORY) {
|
|
const obj2 = {
|
|
section: callback(closure_2[33]).findIndex(self.getSortedNamedCategories(), (id) => {
|
|
id = undefined;
|
|
if (null != channel2) {
|
|
id = channel2.id;
|
|
}
|
|
return id.id === id;
|
|
}) + closure_46
|
|
};
|
|
const items2 = [obj2];
|
|
return items2;
|
|
} else {
|
|
const category = self.getCategory(tmp7);
|
|
if (category instanceof closure_49) {
|
|
let sum = closure_45;
|
|
} else {
|
|
const sortedNamedCategories = self.getSortedNamedCategories();
|
|
sum = sortedNamedCategories.indexOf(category) + closure_46;
|
|
}
|
|
const shownChannelIds2 = category.getShownChannelIds();
|
|
const index2 = shownChannelIds2.indexOf(tmp7.id);
|
|
if (sum >= 0) {
|
|
if (index2 >= 0) {
|
|
let num = 0;
|
|
if (isThreadResult) {
|
|
const threadIds = category.channels[tmp7.id].threadIds;
|
|
num = threadIds.indexOf(channelId);
|
|
}
|
|
const obj3 = { section: sum, row: index2, threadOffset: num };
|
|
items1.push(obj3);
|
|
}
|
|
}
|
|
const voiceChannelsCategory = self.voiceChannelsCategory;
|
|
const shownChannelIds3 = voiceChannelsCategory.getShownChannelIds();
|
|
const index3 = shownChannelIds3.indexOf(tmp7.id);
|
|
if (index3 >= 0) {
|
|
const obj4 = { section: self.voiceChannelsSectionNumber, row: index3 };
|
|
items1.push(obj4);
|
|
}
|
|
return items1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return items1;
|
|
}
|
|
}
|
|
};
|
|
items[14] = {
|
|
key: "getCategory",
|
|
value(parent_id) {
|
|
const self = this;
|
|
if (null != parent_id.parent_id) {
|
|
if (parent_id.parent_id in self.categories) {
|
|
let noParentCategory = self.categories[parent_id.parent_id];
|
|
}
|
|
return noParentCategory;
|
|
}
|
|
noParentCategory = self.noParentCategory;
|
|
}
|
|
};
|
|
items[15] = {
|
|
key: "updateRecentsCategory",
|
|
value() {
|
|
const self = this;
|
|
const recentsCategory = this.recentsCategory;
|
|
const updateAllChannelsResult = recentsCategory.updateAllChannels(this.initializationData);
|
|
if (updateAllChannelsResult) {
|
|
self.invalidate();
|
|
}
|
|
return updateAllChannelsResult;
|
|
}
|
|
};
|
|
items[16] = {
|
|
key: "nonPositionalChannelUpdate",
|
|
value(arg0) {
|
|
const self = this;
|
|
const initializationData = this.initializationData;
|
|
const category = this.getCategory(arg0);
|
|
let flag = category.updateChannel(arg0, initializationData);
|
|
const favoritesCategory = this.favoritesCategory;
|
|
if (favoritesCategory.updateChannel(arg0, initializationData)) {
|
|
flag = true;
|
|
}
|
|
const recentsCategory = self.recentsCategory;
|
|
if (recentsCategory.updateChannel(arg0, initializationData)) {
|
|
flag = true;
|
|
}
|
|
const voiceChannelsCategory = self.voiceChannelsCategory;
|
|
if (voiceChannelsCategory.updateChannel(arg0, initializationData)) {
|
|
flag = true;
|
|
}
|
|
if (flag) {
|
|
self.invalidate();
|
|
}
|
|
return flag;
|
|
}
|
|
};
|
|
items[17] = {
|
|
key: "getSlicedChannels",
|
|
value(arg0, ignoreRecents) {
|
|
let iter5;
|
|
callback(closure_2[39])(arg0.length > 0, "must have at least one channel in the slice");
|
|
const items = [];
|
|
const items1 = [];
|
|
const tmp4 = callback3(this.getSortedCategories());
|
|
const iter = tmp4();
|
|
let iter2 = iter;
|
|
let flag = true;
|
|
let flag2 = false;
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter2.value;
|
|
ignoreRecents = undefined;
|
|
if (null != ignoreRecents) {
|
|
ignoreRecents = ignoreRecents.ignoreRecents;
|
|
}
|
|
if (ignoreRecents) {
|
|
ignoreRecents = value === this.recentsCategory;
|
|
}
|
|
let tmp6 = closure_66;
|
|
let tmp7 = closure_66(value.getShownChannelIds());
|
|
let iter3 = tmp7();
|
|
let tmp8 = flag;
|
|
let flag3 = flag2;
|
|
if (!iter3.done) {
|
|
do {
|
|
let tmp9 = value.channels[iter3.value];
|
|
let tmp10 = tmp8;
|
|
if (tmp8) {
|
|
let flag4 = false;
|
|
if (tmp9.id !== tmp2.id) {
|
|
flag4 = tmp8;
|
|
if (!ignoreRecents) {
|
|
let arr = items.push(tmp9);
|
|
flag4 = tmp8;
|
|
}
|
|
}
|
|
tmp10 = flag4;
|
|
}
|
|
let tmp12 = flag3;
|
|
if (flag3) {
|
|
tmp12 = !ignoreRecents;
|
|
}
|
|
if (tmp12) {
|
|
arr = items1.push(tmp9);
|
|
}
|
|
let tmp14 = tmp10;
|
|
if (!tmp10) {
|
|
tmp14 = flag3;
|
|
}
|
|
let tmp15 = flag3;
|
|
if (!tmp14) {
|
|
if (tmp9.id === tmp3.id) {
|
|
flag3 = true;
|
|
}
|
|
tmp15 = flag3;
|
|
}
|
|
let iter4 = tmp7();
|
|
flag3 = tmp15;
|
|
tmp8 = tmp10;
|
|
iter3 = iter4;
|
|
flag = tmp10;
|
|
flag2 = tmp15;
|
|
let tmp16 = tmp9;
|
|
} while (!iter4.done);
|
|
}
|
|
iter5 = tmp4();
|
|
iter2 = iter5;
|
|
} while (!iter5.done);
|
|
}
|
|
const items2 = [items, arg0, items1];
|
|
return items2;
|
|
}
|
|
};
|
|
items[18] = {
|
|
key: "_initializeAllChannelsById",
|
|
value() {
|
|
let iter2;
|
|
const self = this;
|
|
if (null == this.allChannelsById) {
|
|
self.allChannelsById = {};
|
|
const tmp2 = callback3(self.getSortedCategories());
|
|
let iter = tmp2();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
for (const key10014 in value.channels) {
|
|
let tmp3 = key10014;
|
|
self.allChannelsById[key10014] = value.channels[key10014];
|
|
}
|
|
iter2 = tmp2();
|
|
iter = iter2;
|
|
} while (!iter2.done);
|
|
}
|
|
}
|
|
return self.allChannelsById;
|
|
}
|
|
};
|
|
items[19] = {
|
|
key: "getChannels",
|
|
value(arg0) {
|
|
let iter2;
|
|
const items = [];
|
|
const result = this._initializeAllChannelsById();
|
|
const tmp2 = callback3(arg0);
|
|
let iter = tmp2();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
if (null != result[value]) {
|
|
let arr = items.push(result[value]);
|
|
}
|
|
iter2 = tmp2();
|
|
iter = iter2;
|
|
} while (!iter2.done);
|
|
}
|
|
return items;
|
|
}
|
|
};
|
|
items[20] = {
|
|
key: "getChannel",
|
|
value(arg0) {
|
|
const tmp = this._initializeAllChannelsById()[arg0];
|
|
let tmp2 = null;
|
|
if (null != tmp) {
|
|
tmp2 = tmp;
|
|
}
|
|
return tmp2;
|
|
}
|
|
};
|
|
items[21] = {
|
|
key: "updateSubtitles",
|
|
value(channelId) {
|
|
const self = this;
|
|
const items = [];
|
|
if (null != channelId) {
|
|
const channel = store2.getChannel(channelId);
|
|
let valueResult = items;
|
|
if (null != channel) {
|
|
if (channel.id in self.favoritesCategory.channels) {
|
|
const items1 = [self.favoritesCategory.channels[channel.id]];
|
|
valueResult = items1;
|
|
} else if (channel.id in self.recentsCategory.channels) {
|
|
const items2 = [self.recentsCategory.channels[channel.id]];
|
|
valueResult = items2;
|
|
} else {
|
|
const category = self.getCategory(channel);
|
|
valueResult = items;
|
|
if (tmp7) {
|
|
const items3 = [category.channels[channelId]];
|
|
valueResult = items3;
|
|
}
|
|
const tmp7 = null != category && null != category.channels[channelId];
|
|
}
|
|
}
|
|
} else {
|
|
const tmp3 = callback(closure_2[33]);
|
|
const mapped = callback(closure_2[33])(self.getSortedCategories()).map((channels) => Object.values(channels.channels));
|
|
const tmp3Result = callback(closure_2[33])(self.getSortedCategories());
|
|
valueResult = mapped.flatten().value();
|
|
const iter = mapped.flatten();
|
|
}
|
|
let closure_0 = false;
|
|
const item = valueResult.forEach((updateSubtitle) => {
|
|
if (updateSubtitle.updateSubtitle()) {
|
|
let closure_0 = true;
|
|
}
|
|
});
|
|
if (closure_0) {
|
|
self.version = self.version + 1;
|
|
}
|
|
return closure_0;
|
|
}
|
|
};
|
|
items[22] = {
|
|
key: "forEachShownChannel",
|
|
value(arg0, ignoreRecents) {
|
|
const tmp = callback3(this.getSortedCategories());
|
|
const iter = tmp();
|
|
let iter2 = iter;
|
|
if (!iter.done) {
|
|
while (true) {
|
|
let value = iter2.value;
|
|
if (null != ignoreRecents) {
|
|
if (ignoreRecents.ignoreRecents) {
|
|
let tmp5 = tmp2;
|
|
let tmp6 = tmp3;
|
|
let tmp7 = tmp4;
|
|
}
|
|
let iter9 = tmp();
|
|
let tmp2 = tmp5;
|
|
let tmp3 = tmp6;
|
|
let tmp4 = tmp7;
|
|
iter2 = iter9;
|
|
if (iter9.done) {
|
|
break;
|
|
}
|
|
}
|
|
let tmp8 = callback3;
|
|
let tmp9 = callback3(value.getShownChannelIds());
|
|
let iter3 = tmp9();
|
|
let iter4 = iter3;
|
|
let tmp10 = tmp4;
|
|
let tmp11 = iter3;
|
|
let tmp12 = tmp9;
|
|
tmp5 = tmp2;
|
|
tmp6 = tmp3;
|
|
tmp7 = tmp4;
|
|
if (!iter3.done) {
|
|
do {
|
|
let tmp13 = value.channels[iter4.value];
|
|
let tmp14 = arg0(tmp13.record);
|
|
let tmp15 = closure_66;
|
|
let tmp16 = closure_66(tmp13.threadIds);
|
|
let iter5 = tmp16();
|
|
let iter6 = iter5;
|
|
let tmp17 = iter5;
|
|
if (!iter5.done) {
|
|
do {
|
|
let tmp18 = initialize;
|
|
let channel = initialize.getChannel(iter6.value);
|
|
if (null != channel) {
|
|
let tmp20 = arg0(channel);
|
|
}
|
|
let iter7 = tmp16();
|
|
iter6 = iter7;
|
|
tmp17 = iter7;
|
|
tmp10 = channel;
|
|
} while (!iter7.done);
|
|
}
|
|
let iter8 = tmp9();
|
|
tmp5 = tmp17;
|
|
iter4 = iter8;
|
|
let tmp21 = iter8;
|
|
let tmp22 = tmp9;
|
|
tmp6 = tmp16;
|
|
tmp7 = tmp10;
|
|
} while (!iter8.done);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
items[23] = {
|
|
key: "forEachChannel",
|
|
value(arg0, ignoreRecents) {
|
|
const tmp = callback3(this.getSortedCategories());
|
|
const iter = tmp();
|
|
let iter2 = iter;
|
|
if (!iter.done) {
|
|
while (true) {
|
|
let value = iter2.value;
|
|
if (null != ignoreRecents) {
|
|
let iter6 = tmp();
|
|
iter2 = iter6;
|
|
if (iter6.done) {
|
|
break;
|
|
}
|
|
}
|
|
let tmp2 = callback3;
|
|
let tmp3 = callback3(value.getChannelRecords());
|
|
let iter3 = tmp3();
|
|
let iter4 = iter3;
|
|
let tmp4 = iter3;
|
|
let tmp5 = tmp3;
|
|
if (!iter3.done) {
|
|
do {
|
|
let tmp6 = arg0(iter4.value);
|
|
let iter5 = tmp3();
|
|
iter4 = iter5;
|
|
let tmp7 = iter5;
|
|
let tmp8 = tmp3;
|
|
let done = iter5.done;
|
|
} while (!done);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
return callback3(ChannelListImpl, items);
|
|
}();
|
|
const tmp6 = () => {
|
|
class BaseChannelListCategory {
|
|
constructor(arg0) {
|
|
tmp = _inherits(this, BaseChannelListCategory);
|
|
this.guild = arg0;
|
|
this.isMuted = false;
|
|
this.isCollapsed = false;
|
|
this.position = -1;
|
|
this.channels = {};
|
|
this.shownChannelIds = null;
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = BaseChannelListCategory;
|
|
let obj = {
|
|
key: "updateChannel",
|
|
value(id) {
|
|
const self = this;
|
|
const tmp = id.id in this.channels;
|
|
let tmp2 = !tmp;
|
|
if (tmp) {
|
|
tmp2 = !self.channels[id.id].updateChannel(id, arg1);
|
|
const obj = self.channels[id.id];
|
|
}
|
|
let flag = !tmp2;
|
|
if (!tmp2) {
|
|
self.invalidate();
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
};
|
|
const items = [obj, , , , , , , , ];
|
|
obj = {
|
|
key: "invalidate",
|
|
value() {
|
|
this.shownChannelIds = null;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "getRows",
|
|
value() {
|
|
const self = this;
|
|
const shownChannelIds = this.getShownChannelIds();
|
|
let tmp = shownChannelIds;
|
|
if (0 === shownChannelIds.length) {
|
|
tmp = shownChannelIds;
|
|
if (self.shouldShowEmptyCategory()) {
|
|
const items = ["placeholder-channel-id"];
|
|
tmp = items;
|
|
}
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "shouldShowEmptyCategory",
|
|
value() {
|
|
return callback(closure_2[33]).some(this.channels, (renderLevel) => renderLevel.renderLevel >= obj.WouldShowIfUncollapsed);
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "getShownChannelIds",
|
|
value() {
|
|
const self = this;
|
|
if (null == this.shownChannelIds) {
|
|
const values = callback(closure_2[33])(self.channels).values();
|
|
const found = values.filter((renderLevel) => renderLevel.renderLevel === Show.Show);
|
|
const obj = callback(closure_2[33])(self.channels);
|
|
const sortByResult = found.sortBy((record) => {
|
|
record = record.record;
|
|
const position = record.position;
|
|
if (record.isGuildVocal()) {
|
|
let sum = position + 10000;
|
|
} else {
|
|
sum = position;
|
|
}
|
|
return sum;
|
|
});
|
|
self.shownChannelIds = found.sortBy((record) => {
|
|
record = record.record;
|
|
const position = record.position;
|
|
if (record.isGuildVocal()) {
|
|
let sum = position + 10000;
|
|
} else {
|
|
sum = position;
|
|
}
|
|
return sum;
|
|
}).map((id) => id.id).value();
|
|
const iter = found.sortBy((record) => {
|
|
record = record.record;
|
|
const position = record.position;
|
|
if (record.isGuildVocal()) {
|
|
let sum = position + 10000;
|
|
} else {
|
|
sum = position;
|
|
}
|
|
return sum;
|
|
}).map((id) => id.id);
|
|
}
|
|
return self.shownChannelIds;
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "getShownChannelAndThreadIds",
|
|
value() {
|
|
const values = callback(closure_2[33])(this.channels).values();
|
|
const obj = callback(closure_2[33])(this.channels);
|
|
const iter = values.flatMap((threadIds) => threadIds.threadIds);
|
|
const shownChannelIds = this.getShownChannelIds();
|
|
return shownChannelIds.concat(values.flatMap((threadIds) => threadIds.threadIds).value());
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "isEmpty",
|
|
value() {
|
|
return 0 === this.getShownChannelIds().length;
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "getChannelRecords",
|
|
value() {
|
|
const values = callback(closure_2[33])(this.channels).values();
|
|
const found = values.filter((renderLevel) => renderLevel.renderLevel > CannotShow.CannotShow);
|
|
const obj = callback(closure_2[33])(this.channels);
|
|
return found.map((record) => record.record).value();
|
|
}
|
|
};
|
|
items[8] = {
|
|
key: "getFirstVoiceChannel",
|
|
value(arg0) {
|
|
let value;
|
|
const self = this;
|
|
const tmp = callback3(this.getShownChannelIds());
|
|
const iter = tmp();
|
|
let iter2 = iter;
|
|
if (!iter.done) {
|
|
while (true) {
|
|
value = iter2.value;
|
|
if (arg0) {
|
|
let record = self.channels[value].record;
|
|
if (record.isGuildStageVoice()) {
|
|
break;
|
|
}
|
|
}
|
|
if (!arg0) {
|
|
let record2 = self.channels[value].record;
|
|
if (record2.isGuildVocal()) {
|
|
return self.channels[value];
|
|
}
|
|
}
|
|
let iter3 = tmp();
|
|
iter2 = iter3;
|
|
}
|
|
return self.channels[value];
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
return callback3(BaseChannelListCategory, items);
|
|
}();
|
|
let closure_49 = (arg0) => {
|
|
class ChannelListCategoryNoParent {
|
|
constructor(arg0, arg1, arg2) {
|
|
ChannelListCategoryNoParent = arg2;
|
|
tmp = _inherits(this, ChannelListCategoryNoParent);
|
|
items = [];
|
|
items[0] = arg0;
|
|
tmp2 = closure_64(this, ChannelListCategoryNoParent, items);
|
|
arg2 = tmp2;
|
|
arr2 = arg2(closure_2[33])(arg1);
|
|
mapped = arr2.map((arg0) => new closure_57(tmp2, arg0, arg2));
|
|
iter = mapped.keyBy((id) => id.id);
|
|
tmp2.channels = iter.value();
|
|
return tmp2;
|
|
}
|
|
}
|
|
const arg1 = ChannelListCategoryNoParent;
|
|
callback2(ChannelListCategoryNoParent, arg0);
|
|
return callback3(ChannelListCategoryNoParent);
|
|
}(tmp6);
|
|
let closure_50 = (arg0) => {
|
|
class ChannelListCategoryWithParent {
|
|
constructor(arg0, arg1, arg2, arg3) {
|
|
tmp = _inherits(this, ChannelListCategoryWithParent);
|
|
items = [];
|
|
items[0] = arg0;
|
|
tmp2 = closure_64(this, ChannelListCategoryWithParent, items);
|
|
tmp2.record = arg1;
|
|
tmp2.id = arg1.id;
|
|
tmp2.isCollapsed = true === arg0.collapsedCategoryIds[arg1.id];
|
|
mutedChannelIds = arg0.mutedChannelIds;
|
|
tmp2.isMuted = mutedChannelIds.has(arg1.id);
|
|
tmp2.channels = {};
|
|
tmp3 = closure_66(arg2);
|
|
iter = tmp3();
|
|
if (!iter.done) {
|
|
do {
|
|
value = iter.value;
|
|
tmp4 = closure_57;
|
|
prototype = closure_57.prototype;
|
|
tmp5 = new.target;
|
|
tmp6 = new.target;
|
|
tmp7 = tmp2;
|
|
tmp8 = value;
|
|
tmp9 = arg3;
|
|
tmp10 = new closure_57(tmp2, value, arg3);
|
|
tmp11 = tmp10;
|
|
tmp2.channels[value.id] = tmp10;
|
|
iter2 = tmp3();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
return tmp2;
|
|
}
|
|
}
|
|
const arg1 = ChannelListCategoryWithParent;
|
|
callback2(ChannelListCategoryWithParent, arg0);
|
|
const items = [
|
|
{
|
|
key: "shouldShowEmptyCategory",
|
|
value() {
|
|
const self = this;
|
|
const tmp = !callback3(ChannelListCategoryWithParent, "shouldShowEmptyCategory", this, 3)([]);
|
|
let tmp2 = !tmp;
|
|
if (tmp) {
|
|
let canResult = closure_28.can(constants.MANAGE_CHANNELS, self.record);
|
|
if (canResult) {
|
|
canResult = closure_28.can(constants.VIEW_CHANNEL, self.record);
|
|
}
|
|
if (canResult) {
|
|
canResult = callback(closure_2[33]).isEmpty(self.channels);
|
|
const obj = callback(closure_2[33]);
|
|
}
|
|
let tmp10 = !canResult;
|
|
if (!tmp10) {
|
|
let optInEnabled = self.guild.optInEnabled;
|
|
if (optInEnabled) {
|
|
const optedInChannels = self.guild.optedInChannels;
|
|
optInEnabled = !optedInChannels.has(self.id);
|
|
}
|
|
tmp10 = optInEnabled;
|
|
}
|
|
tmp2 = !tmp10;
|
|
}
|
|
return tmp2;
|
|
}
|
|
}
|
|
];
|
|
return callback3(ChannelListCategoryWithParent, items);
|
|
}(tmp6);
|
|
const tmp7 = (arg0) => {
|
|
class ChannelListFavoritesCategory {
|
|
constructor(arg0, arg1) {
|
|
ChannelListFavoritesCategory = arg1;
|
|
tmp = _inherits(this, ChannelListFavoritesCategory);
|
|
items = [];
|
|
items[0] = arg0;
|
|
tmp2 = closure_64(this, ChannelListFavoritesCategory, items);
|
|
closure_1 = tmp2;
|
|
tmp3 = closure_1(closure_2[33]);
|
|
guildFavorites = closure_31.getGuildFavorites(arg0.id);
|
|
if (null == guildFavorites) {
|
|
guildFavorites = [];
|
|
}
|
|
tmp3Result = tmp3(guildFavorites);
|
|
mapped = tmp3Result.map((channelId) => channel.getChannel(channelId));
|
|
found = mapped.filter(ChannelListFavoritesCategory(closure_2[40]).isNotNullish);
|
|
mapped1 = found.map((arg0) => new closure_58(tmp2, arg0, arg1));
|
|
iter = mapped1.keyBy((id) => id.id);
|
|
tmp2.channels = iter.value();
|
|
suggestedChannelId = closure_15.getSuggestedChannelId(arg0.id);
|
|
channel = initialize.getChannel(suggestedChannelId);
|
|
tmp6 = null != channel && null != suggestedChannelId;
|
|
if (tmp6) {
|
|
tmp7 = closure_58;
|
|
obj = {};
|
|
tmp8 = obj;
|
|
tmp9 = arg1;
|
|
merged = Object.assign(arg1);
|
|
str = "activeJoinedRelevantThreads";
|
|
obj["activeJoinedRelevantThreads"] = {};
|
|
str2 = "activeJoinedUnreadThreads";
|
|
obj["activeJoinedUnreadThreads"] = {};
|
|
prototype = closure_58.prototype;
|
|
tmp11 = new.target;
|
|
tmp12 = new.target;
|
|
tmp13 = tmp2;
|
|
tmp14 = channel;
|
|
tmp15 = obj;
|
|
tmp16 = new closure_58(tmp2, channel, obj);
|
|
tmp17 = tmp16;
|
|
tmp2.channels[suggestedChannelId] = tmp16;
|
|
}
|
|
return tmp2;
|
|
}
|
|
}
|
|
const arg1 = ChannelListFavoritesCategory;
|
|
callback2(ChannelListFavoritesCategory, arg0);
|
|
let obj = {
|
|
key: "updateChannel",
|
|
value(id) {
|
|
const self = this;
|
|
let isFavoriteResult = id.id in this.channels;
|
|
if (isFavoriteResult) {
|
|
isFavoriteResult = closure_31.isFavorite(id.guild_id, id.id);
|
|
}
|
|
const suggestedChannelId = store.getSuggestedChannelId(id.guild_id);
|
|
let tmp5 = arg1;
|
|
if (tmp4) {
|
|
const obj = {};
|
|
const merged = Object.assign(arg1);
|
|
obj["activeJoinedRelevantThreads"] = {};
|
|
obj["activeJoinedUnreadThreads"] = {};
|
|
tmp5 = obj;
|
|
}
|
|
if (id.id in self.channels) {
|
|
if (obj2.updateChannel(id, tmp5)) {
|
|
self.invalidate();
|
|
let flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
let tmp10 = !tmp9;
|
|
if (id.id in self.channels) {
|
|
tmp10 = id.id === suggestedChannelId;
|
|
}
|
|
if (!tmp10) {
|
|
tmp10 = isFavoriteResult;
|
|
}
|
|
flag = !tmp10;
|
|
if (flag) {
|
|
const channels = self.channels;
|
|
id = id.id;
|
|
delete r3[r1];
|
|
self.invalidate();
|
|
flag = true;
|
|
}
|
|
}
|
|
};
|
|
const items = [obj, ];
|
|
obj = {
|
|
key: "getFirstVoiceChannel",
|
|
value() {
|
|
return null;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
return callback3(ChannelListFavoritesCategory, items);
|
|
}(tmp6);
|
|
const tmp8 = (arg0) => {
|
|
class ChannelListRecentlyActiveCategory {
|
|
constructor(arg0, arg1, arg2) {
|
|
tmp = _inherits(this, ChannelListRecentlyActiveCategory);
|
|
items = [];
|
|
items[0] = arg0;
|
|
tmp2 = closure_64(this, ChannelListRecentlyActiveCategory, items);
|
|
tmp2.enabled = false;
|
|
tmp2.isCollapsed = ME.isCollapsed(arg0.id);
|
|
tmp2.enabled = Object.keys(arg1).length >= ChannelListRecentlyActiveCategory.MIN_READABLE_CHANNELS;
|
|
if (tmp2.enabled) {
|
|
_Object = Object;
|
|
values = Object.values(arg1);
|
|
for (let num = 0; num < values.length; num = num + 1) {
|
|
tmp3 = values[num];
|
|
tmp4 = closure_21;
|
|
tmp5 = closure_21(tmp3.type);
|
|
if (tmp5) {
|
|
tmp6 = closure_22;
|
|
tmp5 = !closure_22(tmp3.type);
|
|
}
|
|
if (tmp5) {
|
|
tmp7 = closure_60;
|
|
prototype = closure_60.prototype;
|
|
tmp8 = new.target;
|
|
tmp9 = new.target;
|
|
tmp10 = tmp2;
|
|
tmp11 = tmp3;
|
|
tmp12 = arg2;
|
|
tmp13 = new closure_60(tmp2, tmp3, arg2);
|
|
tmp14 = tmp13;
|
|
tmp2.channels[tmp3.id] = tmp13;
|
|
}
|
|
}
|
|
}
|
|
return tmp2;
|
|
}
|
|
}
|
|
const arg1 = ChannelListRecentlyActiveCategory;
|
|
callback2(ChannelListRecentlyActiveCategory, arg0);
|
|
let obj = {
|
|
key: "shouldShowEmptyCategory",
|
|
value() {
|
|
const self = this;
|
|
let tmp = this.enabled && self.isCollapsed;
|
|
if (tmp) {
|
|
tmp = callback5(ChannelListRecentlyActiveCategory, "shouldShowEmptyCategory", self, 3)([]);
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
const items = [obj, , , , , ];
|
|
obj = {
|
|
key: "updateAllChannels",
|
|
value(arg0) {
|
|
const ChannelListRecentlyActiveCategory = this;
|
|
const values = Object.values(this.channels);
|
|
return values.reduce((arg0, record) => self.updateChannel(record.record, arg0) || arg0, false);
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "updateChannel",
|
|
value(type) {
|
|
const self = this;
|
|
if (this.enabled) {
|
|
if (callback4(type.type)) {
|
|
return null != self.channels[type.parent_id] && self.updateShownChannelIds(self.channels[type.parent_id]);
|
|
} else if (callback3(type.type)) {
|
|
const items = [type, arg1];
|
|
if (null == self.channels[type.id]) {
|
|
const prototype = ctor.prototype;
|
|
const tmp15 = new ctor(self, type, arg1);
|
|
self.channels[type.id] = tmp15;
|
|
self.invalidate();
|
|
let flag3 = true;
|
|
} else {
|
|
flag3 = self.updateShownChannelIds(tmp7) || tmp6;
|
|
}
|
|
return flag3;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "getFirstVoiceChannel",
|
|
value() {
|
|
return null;
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "getShownChannelIds",
|
|
value() {
|
|
const self = this;
|
|
if (null != this.shownChannelIds) {
|
|
return self.shownChannelIds;
|
|
} else {
|
|
const constants = self.isCollapsed ? tmp4.Show : tmp4.WouldShowIfUncollapsed;
|
|
if (self.enabled) {
|
|
const found = callback(closure_2[33])(self.channels).filter((renderLevel) => renderLevel.renderLevel >= closure_0);
|
|
const mapped = found.map((arg0) => {
|
|
const items = [, , ];
|
|
({ id: arr[0], lastMessageTimestamp: arr[1], renderLevel: arr[2] } = arg0);
|
|
return items;
|
|
});
|
|
const found1 = mapped.filter((arg0) => {
|
|
let tmp2;
|
|
let tmp3;
|
|
[, tmp2, tmp3] = arg0;
|
|
let tmp5 = tmp4;
|
|
if (tmp3 !== closure_40.Show) {
|
|
let tmp8 = tmp7;
|
|
if (tmp2 > 0) {
|
|
const _Date = Date;
|
|
tmp8 = Date.now() - tmp < lib.MAX_TIMESTAMP_DELTA;
|
|
}
|
|
tmp5 = tmp8;
|
|
}
|
|
return tmp5;
|
|
});
|
|
const arr2 = callback(closure_2[33])(self.channels);
|
|
const sortByResult = found1.sortBy((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[, tmp, tmp2] = arg0;
|
|
let num = 0;
|
|
if (tmp2 !== closure_40.Show) {
|
|
num = lib(closure_2[41]).DISCORD_EPOCH;
|
|
}
|
|
return -tmp - num;
|
|
});
|
|
const takeResult = found1.sortBy((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[, tmp, tmp2] = arg0;
|
|
let num = 0;
|
|
if (tmp2 !== closure_40.Show) {
|
|
num = lib(closure_2[41]).DISCORD_EPOCH;
|
|
}
|
|
return -tmp - num;
|
|
}).take(constants.MAX_RECENT_CHANNELS);
|
|
const sortByResult1 = found1.sortBy((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[, tmp, tmp2] = arg0;
|
|
let num = 0;
|
|
if (tmp2 !== closure_40.Show) {
|
|
num = lib(closure_2[41]).DISCORD_EPOCH;
|
|
}
|
|
return -tmp - num;
|
|
}).take(constants.MAX_RECENT_CHANNELS).sortBy((arg0) => {
|
|
let tmp;
|
|
[, tmp] = arg0;
|
|
return -tmp;
|
|
});
|
|
let items = found1.sortBy((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[, tmp, tmp2] = arg0;
|
|
let num = 0;
|
|
if (tmp2 !== closure_40.Show) {
|
|
num = lib(closure_2[41]).DISCORD_EPOCH;
|
|
}
|
|
return -tmp - num;
|
|
}).take(constants.MAX_RECENT_CHANNELS).sortBy((arg0) => {
|
|
let tmp;
|
|
[, tmp] = arg0;
|
|
return -tmp;
|
|
}).map((arg0) => {
|
|
let tmp;
|
|
[tmp] = arg0;
|
|
return tmp;
|
|
}).value();
|
|
const iter = found1.sortBy((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[, tmp, tmp2] = arg0;
|
|
let num = 0;
|
|
if (tmp2 !== closure_40.Show) {
|
|
num = lib(closure_2[41]).DISCORD_EPOCH;
|
|
}
|
|
return -tmp - num;
|
|
}).take(constants.MAX_RECENT_CHANNELS).sortBy((arg0) => {
|
|
let tmp;
|
|
[, tmp] = arg0;
|
|
return -tmp;
|
|
}).map((arg0) => {
|
|
let tmp;
|
|
[tmp] = arg0;
|
|
return tmp;
|
|
});
|
|
} else {
|
|
items = [];
|
|
}
|
|
self.shownChannelIds = items;
|
|
}
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "updateShownChannelIds",
|
|
value(renderLevel) {
|
|
const self = this;
|
|
if (null != self.shownChannelIds) {
|
|
if (renderLevel.renderLevel >= tmp) {
|
|
let lastMessageTimestamp;
|
|
if (null != self.channels[self.shownChannelIds[0]]) {
|
|
lastMessageTimestamp = tmp8.lastMessageTimestamp;
|
|
}
|
|
if (renderLevel.lastMessageTimestamp > lastMessageTimestamp) {
|
|
const shownChannelIds = self.shownChannelIds;
|
|
const index = shownChannelIds.indexOf(renderLevel.id);
|
|
if (index > -1) {
|
|
const shownChannelIds1 = self.shownChannelIds;
|
|
shownChannelIds1.splice(index, 1);
|
|
}
|
|
const shownChannelIds2 = self.shownChannelIds;
|
|
shownChannelIds2.splice(0, 0, renderLevel.id);
|
|
if (self.shownChannelIds.length > ChannelListRecentlyActiveCategory.MAX_RECENT_CHANNELS) {
|
|
const shownChannelIds3 = self.shownChannelIds;
|
|
self.shownChannelIds = shownChannelIds3.slice(0, ChannelListRecentlyActiveCategory.MAX_RECENT_CHANNELS);
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
return callback3(ChannelListRecentlyActiveCategory, items);
|
|
}(tmp6);
|
|
tmp8.MIN_READABLE_CHANNELS = 7;
|
|
tmp8.MAX_RECENT_CHANNELS = 10;
|
|
tmp8.MAX_TIMESTAMP_DELTA = 604800000;
|
|
let closure_53 = (arg0) => {
|
|
class ChannelListRecentsCategory {
|
|
constructor(arg0, arg1, arg2) {
|
|
ChannelListRecentsCategory = arg2;
|
|
tmp = _inherits(this, ChannelListRecentsCategory);
|
|
items = [];
|
|
items[0] = arg0;
|
|
tmp2 = closure_64(this, ChannelListRecentsCategory, items);
|
|
closure_1 = tmp2;
|
|
if (arg0.optInEnabled) {
|
|
tmp4 = closure_14;
|
|
if (closure_14.isFullServerPreview(arg0.id)) {
|
|
tmp9 = _defineProperties;
|
|
tmp8 = _defineProperties(tmp2);
|
|
} else {
|
|
flag = false;
|
|
tmp2.isCollapsed = false;
|
|
tmp2.isMuted = false;
|
|
tmp5 = closure_1;
|
|
tmp6 = closure_2;
|
|
num = 33;
|
|
tmp7 = arg1;
|
|
arr2 = closure_1(closure_2[33])(arg1);
|
|
mapped = arr2.map((arg0) => new closure_59(tmp2, arg0, arg2));
|
|
iter = mapped.keyBy((id) => id.id);
|
|
tmp2.channels = iter.value();
|
|
tmp8 = tmp2;
|
|
}
|
|
tmp10 = tmp8;
|
|
} else {
|
|
tmp3 = _defineProperties;
|
|
return _defineProperties(tmp2);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = ChannelListRecentsCategory;
|
|
callback2(ChannelListRecentsCategory, arg0);
|
|
let obj = {
|
|
key: "updateAllChannels",
|
|
value(arg0) {
|
|
const ChannelListRecentsCategory = this;
|
|
let closure_2 = false;
|
|
const keys = arg0(closure_2[41]).keys(this.channels);
|
|
const item = keys.forEach((arg0) => {
|
|
if (self.updateChannel(self.channels[arg0].record, arg0)) {
|
|
let closure_2 = true;
|
|
}
|
|
});
|
|
return closure_2;
|
|
}
|
|
};
|
|
const items = [obj, , , ];
|
|
obj = {
|
|
key: "updateChannel",
|
|
value(id) {
|
|
const self = this;
|
|
const items = [id, arg1];
|
|
if (this.guild.optInEnabled) {
|
|
if (callback6(self.guild, id, arg1)) {
|
|
if (null == self.channels[id.id]) {
|
|
const prototype = ctor.prototype;
|
|
const tmp10 = new ctor(self, id, arg1);
|
|
self.channels[id.id] = tmp10;
|
|
self.invalidate();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return callback4(ChannelListRecentsCategory, "updateChannel", this, 3)(items);
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "getFirstVoiceChannel",
|
|
value() {
|
|
return null;
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "getShownChannelIds",
|
|
value() {
|
|
const self = this;
|
|
if (null == this.shownChannelIds) {
|
|
const values = callback(closure_2[33])(self.channels).values();
|
|
const found = values.filter((renderLevel) => {
|
|
let tmp = renderLevel.renderLevel === closure_40.Show;
|
|
if (!tmp) {
|
|
tmp = renderLevel.renderLevel === closure_40.WouldShowIfUncollapsed;
|
|
}
|
|
return tmp;
|
|
});
|
|
const obj = callback(closure_2[33])(self.channels);
|
|
const sortByResult = found.sortBy((record) => record.record.position);
|
|
const valueResult = found.sortBy((record) => record.record.position).take(5).value();
|
|
const iter = found.sortBy((record) => record.record.position).take(5);
|
|
const _Set = Set;
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(valueResult, HermesBuiltin.arraySpread(found.filter((renderLevel) => renderLevel.renderLevel === closure_40.Show).value(), 0));
|
|
const set = new Set(items);
|
|
const items1 = [];
|
|
const iter2 = found.filter((renderLevel) => renderLevel.renderLevel === closure_40.Show);
|
|
HermesBuiltin.arraySpread(set, 0);
|
|
const tmp14 = callback(closure_2[33]);
|
|
const tmp14Result = callback(closure_2[33])(items1);
|
|
const sortByResult1 = callback(closure_2[33])(items1).sortBy((record) => record.record.position);
|
|
self.shownChannelIds = callback(closure_2[33])(items1).sortBy((record) => record.record.position).map((id) => id.id).value();
|
|
const iter3 = callback(closure_2[33])(items1).sortBy((record) => record.record.position).map((id) => id.id);
|
|
}
|
|
return self.shownChannelIds;
|
|
}
|
|
};
|
|
return callback3(ChannelListRecentsCategory, items);
|
|
}(tmp6);
|
|
const tmp9 = (arg0) => {
|
|
class ChannelListVoiceChannelsCategory {
|
|
constructor(arg0, arg1, arg2, arg3) {
|
|
ChannelListVoiceChannelsCategory = arg3;
|
|
tmp = _inherits(this, ChannelListVoiceChannelsCategory);
|
|
items = [];
|
|
items[0] = arg0;
|
|
tmp2 = closure_64(this, ChannelListVoiceChannelsCategory, items);
|
|
closure_1 = tmp2;
|
|
tmp2.categoriesById = arg2;
|
|
tmp2.hiddenChannelIds = null;
|
|
if (arg0.optInEnabled) {
|
|
tmp5 = closure_34;
|
|
tmp2.isCollapsed = closure_34.isVoiceCategoryCollapsed(arg0.id);
|
|
flag = false;
|
|
tmp2.isMuted = false;
|
|
tmp2.categoriesById = arg2;
|
|
tmp6 = closure_1;
|
|
tmp7 = closure_2;
|
|
num = 33;
|
|
tmp8 = arg1;
|
|
arr2 = closure_1(closure_2[33])(arg1);
|
|
mapped = arr2.map((arg0) => new closure_61(tmp2, arg0, arg3));
|
|
iter = mapped.keyBy((id) => id.id);
|
|
tmp2.channels = iter.value();
|
|
tmp4 = tmp2;
|
|
} else {
|
|
tmp3 = _defineProperties;
|
|
tmp4 = _defineProperties(tmp2);
|
|
}
|
|
return tmp4;
|
|
}
|
|
}
|
|
const arg1 = ChannelListVoiceChannelsCategory;
|
|
callback2(ChannelListVoiceChannelsCategory, arg0);
|
|
let obj = {
|
|
key: "invalidate",
|
|
value() {
|
|
callback4(ChannelListVoiceChannelsCategory, "invalidate", this, 3)([]);
|
|
this.hiddenChannelIds = null;
|
|
}
|
|
};
|
|
const items = [obj, , , , ];
|
|
obj = {
|
|
key: "getHiddenChannelIds",
|
|
value() {
|
|
const self = this;
|
|
if (this.guild.optInEnabled) {
|
|
if (null == self.hiddenChannelIds) {
|
|
const arr = callback(closure_2[33])(self.channels);
|
|
const valueResult = callback(closure_2[33])(self.channels).filter((renderLevel) => renderLevel.renderLevel === obj.WouldShowIfUncollapsed).value();
|
|
if (valueResult.every((record) => {
|
|
record = record.record;
|
|
return record.isCategory();
|
|
})) {
|
|
self.hiddenChannelIds = [];
|
|
return self.hiddenChannelIds;
|
|
} else {
|
|
self.hiddenChannelIds = valueResult.map((id) => id.id);
|
|
}
|
|
const iter = callback(closure_2[33])(self.channels).filter((renderLevel) => renderLevel.renderLevel === obj.WouldShowIfUncollapsed);
|
|
}
|
|
return self.hiddenChannelIds;
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "getRows",
|
|
value() {
|
|
const self = this;
|
|
if (this.guild.optInEnabled) {
|
|
const shownChannelIds = self.getShownChannelIds();
|
|
let tmp = shownChannelIds;
|
|
if (0 === shownChannelIds.length) {
|
|
tmp = shownChannelIds;
|
|
if (self.getHiddenChannelIds().length > 0) {
|
|
const items = ["placeholder-channel-id"];
|
|
tmp = items;
|
|
}
|
|
}
|
|
return tmp;
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "getShownChannelIds",
|
|
value() {
|
|
const self = this;
|
|
const ChannelListVoiceChannelsCategory = this;
|
|
if (this.guild.optInEnabled) {
|
|
if (null == self.shownChannelIds) {
|
|
const found = callback(closure_2[33])(self.channels).filter((renderLevel) => renderLevel.renderLevel === Show.Show);
|
|
const items = [
|
|
(record) => {
|
|
if (record.record.type === constants.GUILD_CATEGORY) {
|
|
let num2 = record.record.position;
|
|
} else {
|
|
num2 = -1;
|
|
if (null != record.record.parent_id) {
|
|
let position;
|
|
if (null != tmp[record.record.parent_id]) {
|
|
position = tmp3.position;
|
|
}
|
|
num2 = -1;
|
|
if (null != position) {
|
|
num2 = position;
|
|
}
|
|
}
|
|
}
|
|
return num2;
|
|
},
|
|
(record) => {
|
|
let num = -1;
|
|
if (record.record.type !== constants.GUILD_CATEGORY) {
|
|
num = record.record.position;
|
|
}
|
|
return num;
|
|
}
|
|
];
|
|
const arr2 = callback(closure_2[33])(self.channels);
|
|
const valueResult = found.orderBy(items, []).value();
|
|
self.shownChannelIds = [];
|
|
let num = 0;
|
|
if (0 < valueResult.length) {
|
|
do {
|
|
let tmp2 = valueResult[num];
|
|
let tmp3 = num < valueResult.length - 1;
|
|
if (tmp3) {
|
|
let tmp4 = closure_36;
|
|
tmp3 = tmp2.record.type === closure_36.GUILD_CATEGORY;
|
|
}
|
|
if (tmp3) {
|
|
let tmp5 = valueResult[num + 1];
|
|
let type;
|
|
if (null != tmp5) {
|
|
type = tmp5.record.type;
|
|
}
|
|
let tmp7 = closure_36;
|
|
tmp3 = type === closure_36.GUILD_CATEGORY;
|
|
let tmp8 = tmp5;
|
|
}
|
|
if (!tmp3) {
|
|
let tmp9 = num === valueResult.length - 1;
|
|
if (tmp9) {
|
|
let tmp10 = closure_36;
|
|
tmp9 = tmp2.record.type === closure_36.GUILD_CATEGORY;
|
|
}
|
|
if (!tmp9) {
|
|
let shownChannelIds = self.shownChannelIds;
|
|
let arr = shownChannelIds.push(tmp2.id);
|
|
}
|
|
}
|
|
num = num + 1;
|
|
} while (num < valueResult.length);
|
|
}
|
|
const iter = found.orderBy(items, []);
|
|
}
|
|
return self.shownChannelIds;
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "getFirstVoiceChannel",
|
|
value() {
|
|
return null;
|
|
}
|
|
};
|
|
return callback3(ChannelListVoiceChannelsCategory, items);
|
|
}(tmp6);
|
|
let closure_55 = () => {
|
|
class ChannelListChannelNoticeSection {
|
|
constructor(arg0) {
|
|
tmp = _inherits(this, ChannelListChannelNoticeSection);
|
|
this.rows = arg0;
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = ChannelListChannelNoticeSection;
|
|
let obj = {
|
|
key: "isEmpty",
|
|
value() {
|
|
return 0 === this.rows.length;
|
|
}
|
|
};
|
|
const items = [obj, , ];
|
|
obj = {
|
|
key: "getRows",
|
|
value() {
|
|
return this.rows;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "getRow",
|
|
value(arg0) {
|
|
return this.rows[arg0];
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
return callback3(ChannelListChannelNoticeSection, items);
|
|
}();
|
|
let closure_56 = () => {
|
|
class ChannelListGuildActionSection {
|
|
constructor(arg0, arg1) {
|
|
tmp = _inherits(this, ChannelListGuildActionSection);
|
|
this.guildActionRows = arg0.map(String);
|
|
if (arg1) {
|
|
guildActionRows = this.guildActionRows;
|
|
_String = String;
|
|
tmp2 = closure_35;
|
|
arr = guildActionRows.push(String(closure_35.GUILD_DIRECTORY));
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = ChannelListGuildActionSection;
|
|
let obj = {
|
|
key: "isEmpty",
|
|
value() {
|
|
return 0 === this.guildActionRows.length;
|
|
}
|
|
};
|
|
const items = [obj, , ];
|
|
obj = {
|
|
key: "getRows",
|
|
value() {
|
|
return this.guildActionRows;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "getRow",
|
|
value(arg0) {
|
|
return this.guildActionRows[arg0];
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
return callback3(ChannelListGuildActionSection, items);
|
|
}();
|
|
const tmp10 = () => {
|
|
class BaseChannelListChannel {
|
|
constructor(arg0, arg1, arg2) {
|
|
self = this;
|
|
tmp = _inherits(this, BaseChannelListChannel);
|
|
this.category = arg0;
|
|
this.record = arg1;
|
|
this.position = -1;
|
|
this.threadIds = [];
|
|
this.threadCount = 0;
|
|
this.subtitle = null;
|
|
this.renderLevel = closure_40.CannotShow;
|
|
this.id = arg1.id;
|
|
state = this.computeState(arg2);
|
|
({ renderLevel, threadIds } = state);
|
|
this.renderLevel = renderLevel;
|
|
obj = closure_1(closure_2[33]);
|
|
this.threadCount = obj.size(threadIds);
|
|
this.threadIds = threadIds;
|
|
if (renderLevel === closure_40.Show) {
|
|
self.subtitle = self.computeSubtitle();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = BaseChannelListChannel;
|
|
let obj = {
|
|
key: "isMuted",
|
|
get() {
|
|
const mutedChannelIds = this.category.guild.mutedChannelIds;
|
|
return mutedChannelIds.has(this.id);
|
|
}
|
|
};
|
|
const items = [obj, , , , , , ];
|
|
obj = {
|
|
key: "isCollapsed",
|
|
get() {
|
|
return collapsed.isCollapsed(this.id);
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "isFirstVoiceChannel",
|
|
get() {
|
|
const category = this.category;
|
|
return category.getFirstVoiceChannel() === this;
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "lastMessageTimestamp",
|
|
get() {
|
|
const items = [closure_29.lastMessageTimestamp(this.id), ...threadIds.map(closure_29.lastMessageTimestamp)];
|
|
const threadIds = this.threadIds;
|
|
return Math.max.apply(items);
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "updateChannel",
|
|
value(record) {
|
|
const self = this;
|
|
let flag = false;
|
|
if (tmp) {
|
|
self.record = record;
|
|
flag = true;
|
|
}
|
|
const state = self.computeState(arg1);
|
|
let isEqualResult = state.renderLevel === self.renderLevel;
|
|
if (isEqualResult) {
|
|
isEqualResult = callback(closure_2[33]).isEqual(state.threadIds, self.threadIds);
|
|
const obj = callback(closure_2[33]);
|
|
}
|
|
if (!isEqualResult) {
|
|
({ renderLevel: self.renderLevel, threadIds: self.threadIds } = state);
|
|
self.threadCount = callback(closure_2[33]).size(state.threadIds);
|
|
flag = true;
|
|
const obj2 = callback(closure_2[33]);
|
|
}
|
|
if (tmp8) {
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "updateSubtitle",
|
|
value() {
|
|
const subtitle = this.computeSubtitle();
|
|
let flag = !callback(closure_2[33]).isEqual(this.subtitle, subtitle);
|
|
if (flag) {
|
|
this.subtitle = subtitle;
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "computeSubtitle",
|
|
value() {
|
|
const self = this;
|
|
let isCollapsed = this.isCollapsed;
|
|
if (!isCollapsed) {
|
|
isCollapsed = self.category.isCollapsed;
|
|
}
|
|
return closure_68(this.record, isCollapsed, self.category.guild.optInEnabled);
|
|
}
|
|
};
|
|
return callback3(BaseChannelListChannel, items);
|
|
}();
|
|
const tmp11 = (arg0) => {
|
|
class ChannelListChannelImpl {
|
|
constructor() {
|
|
tmp = _inherits(this, ChannelListChannelImpl);
|
|
return closure_64(this, ChannelListChannelImpl, arguments);
|
|
}
|
|
}
|
|
const arg1 = ChannelListChannelImpl;
|
|
callback2(ChannelListChannelImpl, arg0);
|
|
const items = [
|
|
{
|
|
key: "computeState",
|
|
value(arg0) {
|
|
let activeJoinedRelevantThreads;
|
|
let activeJoinedUnreadThreads;
|
|
let selectedChannel;
|
|
let selectedVoiceChannelId;
|
|
const self = this;
|
|
({ selectedChannel, selectedVoiceChannelId } = arg0);
|
|
({ activeJoinedRelevantThreads, activeJoinedUnreadThreads } = arg0);
|
|
if (!closure_28.can(constants3.VIEW_CHANNEL, this.record)) {
|
|
if (self.id === selectedVoiceChannelId) {
|
|
let obj = { renderLevel: closure_40.Show, threadIds: [] };
|
|
return obj;
|
|
} else if (!channelGatedAndVisible.isChannelGatedAndVisible(self.record.guild_id, self.record.id)) {
|
|
obj = { renderLevel: closure_40.CannotShow, threadIds: [] };
|
|
return obj;
|
|
}
|
|
}
|
|
const parent_id = self.record.parent_id;
|
|
const guild = self.category.guild;
|
|
if (callback6(guild, self.record)) {
|
|
obj = { renderLevel: closure_40.CannotShow, threadIds: [] };
|
|
return obj;
|
|
} else {
|
|
let id;
|
|
if (null != selectedChannel) {
|
|
id = selectedChannel.id;
|
|
}
|
|
const tmp7 = null != selectedChannel && selectedChannel.isThread() && selectedChannel.parent_id === self.id;
|
|
if (!(id === self.id || selectedVoiceChannelId === self.id)) {
|
|
if (!tmp7) {
|
|
let obj1 = activeJoinedUnreadThreads[self.id];
|
|
}
|
|
if (null == obj1) {
|
|
obj1 = {};
|
|
}
|
|
const tmp12 = callback5(self.record, obj1, selectedChannel, selectedVoiceChannelId, guild.hideMutedChannels);
|
|
if (self.id === guild.moderatorReportChannelId) {
|
|
const obj2 = { renderLevel: closure_40.DoNotShow, threadIds: tmp12 };
|
|
return obj2;
|
|
} else {
|
|
if (guild.optInEnabled) {
|
|
if (guild.hideResourceChannels) {
|
|
const record = self.record;
|
|
if (record.hasFlag(constants2.IS_GUILD_RESOURCE_CHANNEL)) {
|
|
const obj3 = { renderLevel: tmp6 ? closure_40.Show : closure_40.CannotShow, threadIds: tmp12 };
|
|
return obj3;
|
|
}
|
|
}
|
|
}
|
|
if (guild.optInEnabled) {
|
|
const optedInChannels = guild.optedInChannels;
|
|
if (!optedInChannels.has(self.id)) {
|
|
if (null != parent_id) {
|
|
const optedInChannels2 = guild.optedInChannels;
|
|
}
|
|
let obj4 = { renderLevel: closure_40.DoNotShow, threadIds: tmp12 };
|
|
return obj4;
|
|
}
|
|
}
|
|
if (!tmp6) {
|
|
if (!tmp7) {
|
|
obj4 = callback(closure_2[33]);
|
|
if (obj4.isEmpty(tmp12)) {
|
|
if (closure_29.getMentionCount(self.id) <= 0) {
|
|
if (guild.hideMutedChannels) {
|
|
const mutedChannelIds = guild.mutedChannelIds;
|
|
if (mutedChannelIds.has(self.id)) {
|
|
const obj5 = { renderLevel: closure_40.DoNotShow, threadIds: tmp12 };
|
|
return obj5;
|
|
}
|
|
}
|
|
if (self.category.isCollapsed) {
|
|
const mutedChannelIds2 = guild.mutedChannelIds;
|
|
if (!mutedChannelIds2.has(self.id)) {
|
|
if (null != parent_id) {
|
|
const mutedChannelIds3 = guild.mutedChannelIds;
|
|
}
|
|
const record2 = self.record;
|
|
if (!record2.isGuildVocal()) {
|
|
if (self.record.type !== constants.GUILD_STORE) {
|
|
if (callback3(self.record.type)) {
|
|
if (!closure_29.hasUnread(self.record.id)) {
|
|
const obj6 = { renderLevel: closure_40.WouldShowIfUncollapsed, threadIds: tmp12 };
|
|
return obj6;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const obj7 = { renderLevel: closure_40.WouldShowIfUncollapsed, threadIds: tmp12 };
|
|
return obj7;
|
|
}
|
|
const obj8 = { renderLevel: closure_40.WouldShowIfUncollapsed, threadIds: tmp12 };
|
|
return obj8;
|
|
}
|
|
const obj9 = { renderLevel: closure_40.Show, threadIds: tmp12 };
|
|
return obj9;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const obj10 = { renderLevel: closure_40.Show, threadIds: tmp12 };
|
|
return obj10;
|
|
}
|
|
}
|
|
obj1 = activeJoinedRelevantThreads[self.id];
|
|
}
|
|
}
|
|
}
|
|
];
|
|
return callback3(ChannelListChannelImpl, items);
|
|
}(tmp10);
|
|
let closure_58 = (arg0) => {
|
|
class FavoritesChannelListChannel {
|
|
constructor() {
|
|
tmp = _inherits(this, FavoritesChannelListChannel);
|
|
return closure_64(this, FavoritesChannelListChannel, arguments);
|
|
}
|
|
}
|
|
const arg1 = FavoritesChannelListChannel;
|
|
callback2(FavoritesChannelListChannel, arg0);
|
|
const items = [
|
|
{
|
|
key: "computeState",
|
|
value(arg0) {
|
|
let selectedChannel;
|
|
let selectedVoiceChannelId;
|
|
const self = this;
|
|
({ selectedChannel, selectedVoiceChannelId } = arg0);
|
|
let obj = {};
|
|
if (closure_28.can(constants.VIEW_CHANNEL, this.record)) {
|
|
obj.renderLevel = tmp.Show;
|
|
const record = self.record;
|
|
obj = arg0.activeJoinedRelevantThreads[self.id];
|
|
if (null == obj) {
|
|
obj = {};
|
|
}
|
|
obj.threadIds = closure_69(record, obj, selectedChannel, selectedVoiceChannelId, false);
|
|
let tmp2 = obj;
|
|
const tmp3 = closure_69;
|
|
} else {
|
|
obj.renderLevel = tmp.CannotShow;
|
|
obj.threadIds = [];
|
|
tmp2 = obj;
|
|
}
|
|
return tmp2;
|
|
}
|
|
}
|
|
];
|
|
return callback3(FavoritesChannelListChannel, items);
|
|
}(tmp10);
|
|
let closure_59 = (arg0) => {
|
|
class RecentsChannelListChannel {
|
|
constructor() {
|
|
tmp = _inherits(this, RecentsChannelListChannel);
|
|
return closure_64(this, RecentsChannelListChannel, arguments);
|
|
}
|
|
}
|
|
const arg1 = RecentsChannelListChannel;
|
|
callback2(RecentsChannelListChannel, arg0);
|
|
const items = [
|
|
{
|
|
key: "computeState",
|
|
value(arg0) {
|
|
let activeJoinedRelevantThreads;
|
|
let selectedChannel;
|
|
let selectedVoiceChannelId;
|
|
let tmp = arg0;
|
|
let self = this;
|
|
({ selectedChannel, selectedVoiceChannelId, activeJoinedRelevantThreads } = arg0);
|
|
if (closure_28.can(constants.VIEW_CHANNEL, this.record)) {
|
|
let obj = {};
|
|
if (callback4(self.category.guild, self.record, tmp)) {
|
|
tmp = closure_40;
|
|
obj.renderLevel = callback3(self, tmp) ? tmp.Show : tmp.WouldShowIfUncollapsed;
|
|
const record = self.record;
|
|
activeJoinedRelevantThreads = activeJoinedRelevantThreads[self.id];
|
|
if (null == activeJoinedRelevantThreads) {
|
|
activeJoinedRelevantThreads = {};
|
|
}
|
|
self = closure_69(record, activeJoinedRelevantThreads, selectedChannel, selectedVoiceChannelId, false);
|
|
obj.threadIds = self;
|
|
let tmp5 = obj;
|
|
const tmp7 = callback3(self, tmp);
|
|
const tmp8 = closure_69;
|
|
} else {
|
|
obj.renderLevel = closure_40.DoNotShow;
|
|
obj.threadIds = [];
|
|
tmp5 = obj;
|
|
}
|
|
} else {
|
|
obj = { renderLevel: closure_40.CannotShow, threadIds: [] };
|
|
return obj;
|
|
}
|
|
}
|
|
}
|
|
];
|
|
return callback3(RecentsChannelListChannel, items);
|
|
}(tmp10);
|
|
let closure_60 = (arg0) => {
|
|
class RecentlyActiveChannelListChannel {
|
|
constructor() {
|
|
tmp = _inherits(this, RecentlyActiveChannelListChannel);
|
|
return closure_64(this, RecentlyActiveChannelListChannel, arguments);
|
|
}
|
|
}
|
|
const arg1 = RecentlyActiveChannelListChannel;
|
|
callback2(RecentlyActiveChannelListChannel, arg0);
|
|
const items = [
|
|
{
|
|
key: "computeState",
|
|
value(arg0) {
|
|
let renderLevel;
|
|
let threadIds;
|
|
const self = this;
|
|
const items = [arg0];
|
|
({ renderLevel, threadIds } = callback3(RecentlyActiveChannelListChannel, "computeState", this, 3)(items));
|
|
let sortByResult = threadIds;
|
|
let tmp3 = renderLevel;
|
|
if (renderLevel > closure_40.CannotShow) {
|
|
const parent_id = self.record.parent_id;
|
|
const guild = self.category.guild;
|
|
const mutedChannelIds2 = guild.mutedChannelIds;
|
|
if (!mutedChannelIds2.has(self.id)) {
|
|
if (null != parent_id) {
|
|
const mutedChannelIds = guild.mutedChannelIds;
|
|
let tmp13 = renderLevel === closure_40.WouldShowIfUncollapsed;
|
|
if (tmp13) {
|
|
tmp13 = callback5(self, arg0);
|
|
}
|
|
if (tmp13) {
|
|
renderLevel = closure_40.Show;
|
|
}
|
|
let obj = callback(closure_2[33]);
|
|
sortByResult = obj.sortBy(threadIds, (arg0) => -closure_29.lastMessageTimestamp(arg0));
|
|
tmp3 = renderLevel;
|
|
}
|
|
let tmp6 = renderLevel === closure_40.Show;
|
|
if (!tmp6) {
|
|
let tmp8 = renderLevel === closure_40.DoNotShow;
|
|
if (tmp8) {
|
|
tmp8 = callback6(self.category.guild, self.record, arg0);
|
|
}
|
|
tmp6 = tmp8;
|
|
}
|
|
if (tmp6) {
|
|
renderLevel = closure_40.WouldShowIfUncollapsed;
|
|
}
|
|
}
|
|
renderLevel = closure_40.DoNotShow;
|
|
}
|
|
obj = { renderLevel: tmp3, threadIds: sortByResult };
|
|
return obj;
|
|
}
|
|
}
|
|
];
|
|
return callback3(RecentlyActiveChannelListChannel, items);
|
|
}(tmp11);
|
|
let closure_61 = (arg0) => {
|
|
class VoiceChannelListChannel {
|
|
constructor() {
|
|
tmp = _inherits(this, VoiceChannelListChannel);
|
|
return closure_64(this, VoiceChannelListChannel, arguments);
|
|
}
|
|
}
|
|
const arg1 = VoiceChannelListChannel;
|
|
callback2(VoiceChannelListChannel, arg0);
|
|
let obj = {
|
|
key: "getRenderLevel",
|
|
value(arg0) {
|
|
const self = this;
|
|
if (closure_28.can(constants.VIEW_CHANNEL, this.record)) {
|
|
if (arg0 !== tmp.Show) {
|
|
if (arg0 !== closure_40.WouldShowIfUncollapsed) {
|
|
if (!callback5(this.category.guild, self.record)) {
|
|
if (self.category.isCollapsed) {
|
|
callback(closure_2[33]).some(voiceStatesForChannel.getVoiceStatesForChannel(self.record.id)) ? closure_40.Show : closure_40.WouldShowIfUncollapsed;
|
|
const obj = callback(closure_2[33]);
|
|
} else {
|
|
let CannotShow = closure_40.Show;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
CannotShow = closure_40.CannotShow;
|
|
} else {
|
|
return tmp.CannotShow;
|
|
}
|
|
}
|
|
};
|
|
const items = [obj, ];
|
|
obj = {
|
|
key: "computeState",
|
|
value(arg0) {
|
|
const self = this;
|
|
const items = [arg0];
|
|
const renderLevel = this.getRenderLevel(callback3(VoiceChannelListChannel, "computeState", this, 3)(items).renderLevel);
|
|
if (renderLevel === closure_40.Show) {
|
|
let isCollapsed = self.isCollapsed;
|
|
if (!isCollapsed) {
|
|
isCollapsed = self.category.isCollapsed;
|
|
}
|
|
self.subtitle = closure_68(self.record, isCollapsed, self.category.guild.optInEnabled);
|
|
const tmp2 = closure_68;
|
|
}
|
|
return { threadIds: [], renderLevel };
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
return callback3(VoiceChannelListChannel, items);
|
|
}(tmp11);
|
|
const set1 = new Set(Object.values(ChannelListGuildActionRow));
|
|
const result = maybeFetchCollectiblesForInvoices.fileFinishedImporting("modules/guild_sidebar/ChannelListState.tsx");
|
|
|
|
export default () => {
|
|
class ChannelListStates {
|
|
constructor() {
|
|
tmp = _inherits(this, ChannelListStates);
|
|
this.guilds = {};
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = ChannelListStates;
|
|
let obj = {
|
|
key: "_areGuildActionRowsUpdated",
|
|
value(arg0, arg1) {
|
|
let found;
|
|
const obj2 = this.guilds[arg0];
|
|
if (null != obj2) {
|
|
const guildActionSection = obj2.getGuildActionSection();
|
|
const rows = guildActionSection.getRows();
|
|
found = rows.filter((arg0) => !set.has(arg0));
|
|
}
|
|
return !callback(closure_2[33]).isEqual(found, arg1);
|
|
}
|
|
};
|
|
const items = [obj, , , , , , , , , , ];
|
|
obj = {
|
|
key: "_areChannelNoticeRowsUpdated",
|
|
value(arg0, arg1) {
|
|
let rows;
|
|
const obj2 = this.guilds[arg0];
|
|
if (null != obj2) {
|
|
const channelNoticeSection = obj2.getChannelNoticeSection();
|
|
rows = channelNoticeSection.getRows();
|
|
}
|
|
return !callback(closure_2[33]).isEqual(rows, arg1);
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "_areGuildVocalChannelsInRecentsInNeedOfAppearingInActiveNow",
|
|
value(arg0) {
|
|
const obj = this.guilds[arg0];
|
|
if (null == obj) {
|
|
return false;
|
|
} else {
|
|
const categoryFromSection = obj.getCategoryFromSection(obj.voiceChannelsSectionNumber);
|
|
const categoryFromSection1 = obj.getCategoryFromSection(obj.recentsSectionNumber);
|
|
for (const key10005 in categoryFromSection1.channels) {
|
|
let tmp7 = key10005;
|
|
let tmp8 = categoryFromSection1.channels[key10005];
|
|
let tmp9 = closure_40;
|
|
if (tmp8.renderLevel !== closure_40.DoNotShow) {
|
|
continue;
|
|
} else {
|
|
let record = tmp8.record;
|
|
if (!record.isGuildVocal()) {
|
|
continue;
|
|
} else {
|
|
if (null != categoryFromSection.channels[tmp8.id]) {
|
|
continue;
|
|
} else {
|
|
let tmp = closure_1;
|
|
let tmp2 = closure_2;
|
|
let obj2 = closure_1(closure_2[33]);
|
|
let tmp3 = closure_32;
|
|
if (!obj2.some(closure_32.getVoiceStatesForChannel(tmp8.id))) {
|
|
continue;
|
|
} else {
|
|
let tmp4 = closure_29;
|
|
if (closure_29.getMentionCount(tmp8.id) <= 0) {
|
|
continue;
|
|
} else {
|
|
let flag3 = true;
|
|
return true;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "getGuild",
|
|
value(arg0, arg1, arg2) {
|
|
const self = this;
|
|
const tmp = arg0 in this.guilds;
|
|
let result = !tmp;
|
|
if (tmp) {
|
|
result = self._areGuildActionRowsUpdated(arg0, arg1);
|
|
}
|
|
if (!result) {
|
|
result = self._areChannelNoticeRowsUpdated(arg0, arg2);
|
|
}
|
|
if (!result) {
|
|
result = self._areGuildVocalChannelsInRecentsInNeedOfAppearingInActiveNow(arg0);
|
|
}
|
|
if (result) {
|
|
const prototype = ctor.prototype;
|
|
const tmp9 = new ctor(arg0, arg1, arg2);
|
|
self.guilds[arg0] = tmp9;
|
|
}
|
|
return self.guilds[arg0];
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "getGuildChannelRowsOnly",
|
|
value(arg0) {
|
|
const self = this;
|
|
if (!(arg0 in this.guilds)) {
|
|
const prototype = ctor.prototype;
|
|
const tmp5 = new ctor(arg0, [], []);
|
|
self.guilds[arg0] = tmp5;
|
|
}
|
|
return self.guilds[arg0];
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "clear",
|
|
value() {
|
|
this.guilds = {};
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "clearGuildId",
|
|
value(arg0) {
|
|
const self = this;
|
|
let flag = null != arg0 && arg0 in self.guilds;
|
|
if (flag) {
|
|
const guilds = self.guilds;
|
|
delete r1[r2];
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "updateRecentsCategory",
|
|
value(arg0) {
|
|
const self = this;
|
|
let tmp = null != arg0 && arg0 in self.guilds;
|
|
if (tmp) {
|
|
let result;
|
|
if (null != self.guilds[arg0]) {
|
|
result = obj.updateRecentsCategory();
|
|
}
|
|
tmp = null != result && result;
|
|
const tmp3 = null != result && result;
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
items[8] = {
|
|
key: "nonPositionalChannelIdUpdate",
|
|
value(channelId) {
|
|
const self = this;
|
|
let basicChannel = store.getBasicChannel(channelId);
|
|
let tmp2 = null != basicChannel;
|
|
if (tmp2) {
|
|
let tmp3 = null != basicChannel.guild_id;
|
|
if (tmp3) {
|
|
let tmp4 = null != self.guilds[basicChannel.guild_id];
|
|
if (tmp4) {
|
|
let result = basicChannel instanceof closure_20;
|
|
if (!result) {
|
|
const channel = store.getChannel(channelId);
|
|
result = null != channel;
|
|
basicChannel = channel;
|
|
}
|
|
if (result) {
|
|
result = self.nonPositionalChannelUpdate(basicChannel);
|
|
}
|
|
tmp4 = result;
|
|
}
|
|
tmp3 = tmp4;
|
|
}
|
|
tmp2 = tmp3;
|
|
}
|
|
return tmp2;
|
|
}
|
|
};
|
|
items[9] = {
|
|
key: "nonPositionalChannelUpdate",
|
|
value(guild_id) {
|
|
const self = this;
|
|
if (null == guild_id.guild_id) {
|
|
return false;
|
|
} else if (null == self.guilds[guild_id.guild_id]) {
|
|
return false;
|
|
} else {
|
|
let flag = false;
|
|
if (guild_id.isThread()) {
|
|
flag = self.nonPositionalChannelIdUpdate(guild_id.parent_id);
|
|
}
|
|
return obj.nonPositionalChannelUpdate(guild_id) || flag;
|
|
}
|
|
}
|
|
};
|
|
items[10] = {
|
|
key: "updateSubtitles",
|
|
value(arg0, arg1) {
|
|
const self = this;
|
|
const ChannelListStates = arg1;
|
|
if (null == arg0) {
|
|
const _Object = Object;
|
|
let items = Object.values(self.guilds);
|
|
} else if (arg0 in self.guilds) {
|
|
items = [self.guilds[arg0]];
|
|
} else {
|
|
items = [];
|
|
}
|
|
const item = items.forEach((updateSubtitles) => updateSubtitles.updateSubtitles(arg1));
|
|
}
|
|
};
|
|
return callback3(ChannelListStates, items);
|
|
}();
|
|
export const MAX_NEW_CHANNELS_TO_SHOW = 2;
|
|
export const ChannelListSections = obj;
|
|
export const SECTION_INDEX_CHANNEL_NOTICES = CHANNEL_NOTICES;
|
|
export const SECTION_INDEX_GUILD_ACTIONS = GUILD_ACTIONS;
|
|
export const SECTION_INDEX_FAVORITES = FAVORITES;
|
|
export const SECTION_INDEX_RECENTS = RECENTS;
|
|
export const SECTION_INDEX_UNCATEGORIZED_CHANNELS = UNCATEGORIZED_CHANNELS;
|
|
export const SECTION_INDEX_FIRST_NAMED_CATEGORY = FIRST_NAMED_CATEGORY;
|
|
export const ChannelListFavoritesCategory = tmp7;
|
|
export const ChannelListVoiceChannelsCategory = tmp9;
|
|
export const computeSubtitle = _computeSubtitle;
|
|
export { computeThreadIds };
|