A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
import {Routes} from '@app/app/Routes';
import {ResettableStates} from '@app/features/app/state/ResettableStates';
import {cleanupChannelLocalState} from '@app/features/channel/events/ChannelDelete';
import Channels from '@app/features/channel/state/Channels';
import ForumPosts from '@app/features/forum/state/ForumPosts';
import ForumReadState from '@app/features/forum/state/ForumReadState';
import type {GuildReadyData} from '@app/features/gateway/types/GatewayGuildTypes';
import Messages from '@app/features/messaging/state/MessagingMessages';
import Navigation from '@app/features/navigation/state/Navigation';
import * as RouterUtils from '@app/features/navigation/utils/RouterUtils';
import ChannelThreads from '@app/features/threads/state/ChannelThreads';
import ThreadPanel from '@app/features/threads/state/ThreadPanel';
import * as ContextMenuCommands from '@app/features/ui/commands/ContextMenuCommands';
import * as PopoutCommands from '@app/features/ui/commands/PopoutCommands';
import {THREAD_ONLY_CHANNEL_TYPES} from '@fluxer/constants/src/ThreadConstants';
import {isObjectLike} from '@fluxer/record_utils/src/RecordGuards';
import {makeAutoObservable, observable} from 'mobx';
class ThreadGuilds {
private readonly activeGuildIds = observable.set<string>();
readonly purgedThreadIds = new Set<string>();
private readonly purgedByGuild = new Map<string, ReadonlyArray<string>>();
constructor() {
makeAutoObservable<this, 'activeGuildIds' | 'purgedByGuild'>(
this,
{activeGuildIds: false, purgedThreadIds: false, purgedByGuild: false},
{autoBind: true},
);
}
get anyActive(): boolean {
return this.activeGuildIds.size > 0;
}
isActive(guildId: string | null | undefined): boolean {
return guildId != null && this.activeGuildIds.has(guildId);
}
get guildIds(): ReadonlyArray<string> {
return Array.from(this.activeGuildIds);
}
handleGatewayReady(guilds: ReadonlyArray<GuildReadyData>): void {
const present = new Set(guilds.map((guild) => guild.id));
for (const guildId of Array.from(this.activeGuildIds)) {
if (!present.has(guildId)) this.deactivate(guildId);
}
for (const guild of guilds) {
if (!guild.unavailable) this.handleGuild(guild);
}
const {guildId, channelId, threadId} = Navigation;
if (threadId == null || guildId == null || channelId == null || this.activeGuildIds.has(guildId)) return;
const readyGuild = guilds.find((guild) => guild.id === guildId && !guild.unavailable);
if (!readyGuild) return;
const channel = readyGuild.channels.find((candidate) => candidate.id === channelId);
const keepChannel = channel !== undefined && !THREAD_ONLY_CHANNEL_TYPES.has(channel.type);
RouterUtils.replaceWith(Routes.guildChannel(guildId, keepChannel ? channelId : undefined));
}
handleGuild(guild: GuildReadyData): void {
if ('threads' in guild && guild.threads !== undefined) {
this.activate(guild.id);
} else if (this.activeGuildIds.has(guild.id)) {
this.deactivate(guild.id);
}
}
handleGuildDelete(guildId: string, unavailable: boolean): void {
ChannelThreads.handleGuildRemoved(guildId);
if (!unavailable) this.activeGuildIds.delete(guildId);
}
private activate(guildId: string): void {
const purged = this.purgedByGuild.get(guildId);
if (purged) {
for (const threadId of purged) this.purgedThreadIds.delete(threadId);
this.purgedByGuild.delete(guildId);
}
this.activeGuildIds.add(guildId);
}
private deactivate(guildId: string): void {
this.activeGuildIds.delete(guildId);
this.purgeGuild(guildId);
}
purgeGuild(guildId: string): void {
const openThreadId = Navigation.guildId === guildId ? (Navigation.threadId ?? Navigation.channelId) : null;
let fallbackChannelId: string | null = null;
if (Navigation.threadId != null) {
fallbackChannelId = Navigation.channelId;
} else if (openThreadId != null) {
fallbackChannelId = Channels.getChannel(openThreadId)?.parentId ?? null;
}
const createTarget = ThreadPanel.createTarget;
if (createTarget && Channels.getChannel(createTarget.parentId)?.guildId === guildId) ThreadPanel.closeCreate();
const threadIds = ChannelThreads.purgeGuild(guildId);
for (const threadId of threadIds) this.purgedThreadIds.add(threadId);
if (threadIds.length > 0) this.purgedByGuild.set(guildId, threadIds);
for (const channel of [...Channels.getGuildChannels(guildId)]) {
if (THREAD_ONLY_CHANNEL_TYPES.has(channel.type)) {
cleanupChannelLocalState(channel.toJSON());
ForumPosts.purgeForum(channel.id, threadIds);
}
}
ForumReadState.purgeGuild(guildId);
Messages.handleGuildThreadsPurged(guildId);
Messages.handleCleanup();
ContextMenuCommands.close();
PopoutCommands.closeAll();
if (openThreadId != null && threadIds.includes(openThreadId)) {
let routeChannelId: string | undefined;
if (fallbackChannelId != null && Channels.getChannel(fallbackChannelId) !== undefined) {
routeChannelId = fallbackChannelId;
}
RouterUtils.replaceWith(Routes.guildChannel(guildId, routeChannelId));
}
}
isPurgedEvent(data: unknown): boolean {
if (this.purgedThreadIds.size === 0 || !isObjectLike(data)) return false;
const channelId = data.channel_id;
return typeof channelId === 'string' && this.purgedThreadIds.has(channelId);
}
reset(): void {
this.activeGuildIds.clear();
this.purgedThreadIds.clear();
this.purgedByGuild.clear();
}
}
const threadGuilds = new ThreadGuilds();
ResettableStates.register(threadGuilds, () => threadGuilds.reset());
export default threadGuilds;