Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

feat(app): track mentions from other signed-in accounts

Hampus58dc976158a7
diff --git a/fluxer_app/src/features/inbox/state/OtherAccountsInbox.ts b/fluxer_app/src/features/inbox/state/OtherAccountsInbox.ts
new file mode 100644
index 000000000..ea991f3af
--- /dev/null
+++ b/fluxer_app/src/features/inbox/state/OtherAccountsInbox.ts
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import AccountEngine from '@app/features/account_engine/state/AccountEngine';
+import {OtherAccountsInboxState} from '@app/features/inbox/state/OtherAccountsInboxState';
+import {AppStorageKey} from '@app/features/platform/state/AppStorageKeys';
+import AppStorage from '@app/features/platform/state/PersistentStorage';
+
+export default new OtherAccountsInboxState(AccountEngine, AppStorage, AppStorageKey.UI_INBOX_OTHER_ACCOUNTS_COLLAPSED);
diff --git a/fluxer_app/src/features/inbox/state/OtherAccountsInboxState.ts b/fluxer_app/src/features/inbox/state/OtherAccountsInboxState.ts
new file mode 100644
index 000000000..2ccfffe59
--- /dev/null
+++ b/fluxer_app/src/features/inbox/state/OtherAccountsInboxState.ts
@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {Logger} from '@app/features/platform/utils/AppLogger';
+import type {
+ AccountEngineAccountActivity,
+ AccountEngineChannelActivity,
+} from '@fluxer/desktop_ipc/src/AccountEngineContract';
+import {compare as compareSnowflakes} from '@fluxer/snowflake/src/SnowflakeUtils';
+import {makeAutoObservable, runInAction} from 'mobx';
+
+const logger = new Logger('OtherAccountsInboxState');
+
+const OTHER_ACCOUNTS_INBOX_CHANNEL_LIMIT = 8;
+const OTHER_ACCOUNTS_INBOX_MENTION_LIMIT = 3;
+
+interface OtherAccountsInboxEngine {
+ loadActivity(options: {
+ channelLimit: number;
+ mentionLimit: number;
+ }): Promise<ReadonlyArray<AccountEngineAccountActivity>>;
+ ackChannel(accountKey: string, channelId: string, messageId: string): Promise<boolean>;
+}
+
+interface OtherAccountsInboxStorage {
+ getItem(key: string): string | null;
+ setItem(key: string, value: string): void;
+}
+
+interface ReadOverride {
+ readonly messageId: string;
+ readonly settled: boolean;
+}
+
+function readOverrideKey(accountKey: string, channelId: string): string {
+ return `${accountKey}|${channelId}`;
+}
+
+function hasUnreadActivity(channel: AccountEngineChannelActivity): boolean {
+ return channel.mentionCount > 0 || channel.unread;
+}
+
+export class OtherAccountsInboxState {
+ collapsed: boolean;
+ activity: ReadonlyArray<AccountEngineAccountActivity> = [];
+ loading = false;
+ private readOverrides = new Map<string, ReadOverride>();
+ private generation = 0;
+
+ constructor(
+ private readonly engine: OtherAccountsInboxEngine,
+ private readonly storage: OtherAccountsInboxStorage,
+ private readonly storageKey: string,
+ ) {
+ this.collapsed = storage.getItem(storageKey) === 'true';
+ makeAutoObservable<this, 'engine' | 'storage' | 'storageKey' | 'generation'>(
+ this,
+ {engine: false, storage: false, storageKey: false, generation: false},
+ {autoBind: true},
+ );
+ }
+
+ setCollapsed(collapsed: boolean): void {
+ this.collapsed = collapsed;
+ this.storage.setItem(this.storageKey, collapsed ? 'true' : 'false');
+ }
+
+ toggleCollapsed(): void {
+ this.setCollapsed(!this.collapsed);
+ }
+
+ async load(): Promise<void> {
+ const generation = ++this.generation;
+ this.loading = true;
+ const activity = await this.engine.loadActivity({
+ channelLimit: OTHER_ACCOUNTS_INBOX_CHANNEL_LIMIT,
+ mentionLimit: OTHER_ACCOUNTS_INBOX_MENTION_LIMIT,
+ });
+ if (generation !== this.generation) return;
+ runInAction(() => {
+ this.activity = activity;
+ this.loading = false;
+ this.pruneSettledOverrides(activity);
+ });
+ }
+
+ reset(): void {
+ this.generation += 1;
+ this.activity = [];
+ this.loading = false;
+ this.readOverrides.clear();
+ }
+
+ private pruneSettledOverrides(activity: ReadonlyArray<AccountEngineAccountActivity>): void {
+ const latest = new Map<string, string | null>();
+ for (const account of activity) {
+ for (const channel of account.channels) {
+ latest.set(readOverrideKey(account.accountKey, channel.channelId), channel.lastMessageId);
+ }
+ }
+ for (const [key, override] of this.readOverrides) {
+ if (!override.settled) continue;
+ const lastMessageId = latest.get(key);
+ if (lastMessageId == null || compareSnowflakes(lastMessageId, override.messageId) > 0) {
+ this.readOverrides.delete(key);
+ }
+ }
+ }
+
+ isMarkedRead(accountKey: string, channel: AccountEngineChannelActivity): boolean {
+ const override = this.readOverrides.get(readOverrideKey(accountKey, channel.channelId));
+ if (override == null) return false;
+ return channel.lastMessageId == null || compareSnowflakes(channel.lastMessageId, override.messageId) <= 0;
+ }
+
+ visibleChannels(account: AccountEngineAccountActivity): Array<AccountEngineChannelActivity> {
+ const channels = account.channels.filter(
+ (channel) => hasUnreadActivity(channel) && !this.isMarkedRead(account.accountKey, channel),
+ );
+ const mentioned = channels.filter((channel) => channel.mentionCount > 0);
+ const unread = channels.filter((channel) => channel.mentionCount === 0);
+ return [...mentioned, ...unread];
+ }
+
+ get visibleAccounts(): Array<AccountEngineAccountActivity> {
+ return this.activity.filter((account) => this.visibleChannels(account).length > 0 || account.mentions.length > 0);
+ }
+
+ async markAsRead(accountKey: string, channel: AccountEngineChannelActivity): Promise<boolean> {
+ const messageId = channel.lastMessageId;
+ if (messageId == null) return false;
+ const key = readOverrideKey(accountKey, channel.channelId);
+ this.readOverrides.set(key, {messageId, settled: false});
+ let acked = false;
+ try {
+ acked = await this.engine.ackChannel(accountKey, channel.channelId, messageId);
+ } catch (error) {
+ logger.warn(
+ 'Failed to acknowledge a channel on another account',
+ {accountKey, channelId: channel.channelId},
+ error,
+ );
+ acked = false;
+ }
+ runInAction(() => {
+ const current = this.readOverrides.get(key);
+ if (current == null || current.messageId !== messageId) return;
+ if (acked) {
+ this.readOverrides.set(key, {messageId, settled: true});
+ } else {
+ this.readOverrides.delete(key);
+ }
+ });
+ return acked;
+ }
+}
diff --git a/fluxer_app/src/features/messaging/utils/markdown/Plaintext.ts b/fluxer_app/src/features/messaging/utils/markdown/Plaintext.ts
index 9945bc67c..4215a8601 100644
--- a/fluxer_app/src/features/messaging/utils/markdown/Plaintext.ts
+++ b/fluxer_app/src/features/messaging/utils/markdown/Plaintext.ts
@@ -50,6 +50,7 @@ export interface PlaintextRenderOptions {
includeEmojiNames?: boolean;
includeLinkUrls?: boolean;
mentionChannels?: ReadonlyArray<ChannelMention>;
+ resolveFromStores?: boolean;
i18n: I18n;
}
@@ -366,6 +367,9 @@ function renderMentionToPlaintext(node: MentionNode, options: PlaintextRenderOpt
const {kind} = node;
switch (kind.kind) {
case MentionKind.User: {
+ if (options.resolveFromStores === false) {
+ return `@${options.i18n._(UNKNOWN_MENTION_LABEL)}`;
+ }
const user = Users.getUser(kind.id);
if (!user) {
return `@${kind.id}`;
@@ -374,6 +378,9 @@ function renderMentionToPlaintext(node: MentionNode, options: PlaintextRenderOpt
return `@${NicknameUtils.getNickname(user, channel?.guildId ?? null, options.channelId)}`;
}
case MentionKind.Role: {
+ if (options.resolveFromStores === false) {
+ return `@${options.i18n._(UNKNOWN_ROLE_MENTION_LABEL)}`;
+ }
const channel = options.channelId ? Channels.getChannel(options.channelId) : null;
const guild = Guilds.getGuild(channel?.guildId ?? '');
const role = guild ? guild.roles[kind.id] : null;
@@ -383,7 +390,7 @@ function renderMentionToPlaintext(node: MentionNode, options: PlaintextRenderOpt
return `@${role.name}`;
}
case MentionKind.Channel: {
- const channel = Channels.getChannel(kind.id);
+ const channel = options.resolveFromStores === false ? undefined : Channels.getChannel(kind.id);
if (channel && COPYABLE_CHANNEL_MENTION_TYPES.has(channel.type)) {
return `#${channel.name}`;
}
@@ -498,10 +505,6 @@ function renderToPlaintext(nodes: Array<Node>, options: PlaintextRenderOptions):
.replace(/^\n+|\n+$/gu, '');
}
-export function renderAstToPlaintext(nodes: Array<Node>, options: PlaintextRenderOptions): string {
- return renderToPlaintext(nodes, options);
-}
-
export function parseAndRenderToPlaintext(
content: string,
parserFlags: number,
diff --git a/fluxer_app/src/features/notification/utils/MessageNotificationPreview.ts b/fluxer_app/src/features/notification/utils/MessageNotificationPreview.ts
index 5303ff1c0..fbb499156 100644
--- a/fluxer_app/src/features/notification/utils/MessageNotificationPreview.ts
+++ b/fluxer_app/src/features/notification/utils/MessageNotificationPreview.ts
@@ -8,11 +8,11 @@ import {getParserFlagsForContext} from '@app/features/messaging/utils/markdown/M
import {parseAndRenderToPlaintext} from '@app/features/messaging/utils/markdown/Plaintext';
import {SystemMessageUtils} from '@app/features/messaging/utils/SystemMessageUtils';
import {MessageTypes} from '@fluxer/constants/src/ChannelConstants';
+import {inlineMentionedUserNames} from '@fluxer/desktop_ipc/src/AccountEngineContract';
import type {MessageEmbed} from '@fluxer/schema/src/domains/message/EmbedSchemas';
import type {
ChannelMention,
MessageAttachment,
- MessageMention,
MessageSnapshot,
MessageStickerItem,
Message as WireMessage,
@@ -43,6 +43,7 @@ const STICKERS_NOTIFICATION_BODY_DESCRIPTOR = msg({
interface MarkdownPreviewOptions {
channelId: string;
mentionChannels?: ReadonlyArray<ChannelMention>;
+ resolveFromStores?: boolean;
i18n: I18n;
}
@@ -63,6 +64,7 @@ function renderMarkdownPreview(content: string | null | undefined, options: Mark
preserveMarkdown: true,
includeEmojiNames: true,
mentionChannels: options.mentionChannels,
+ resolveFromStores: options.resolveFromStores,
i18n: options.i18n,
});
}
@@ -166,24 +168,14 @@ export function buildMessageNotificationBody(message: Message, i18n: I18n): stri
return '';
}
-const USER_MENTION_PATTERN = /<@!?(\d+)>/g;
-
-function inlineUserMentions(content: string, mentions: ReadonlyArray<MessageMention> | undefined): string {
- if (!content || !mentions?.length) return content;
- return content.replace(USER_MENTION_PATTERN, (token, userId: string) => {
- const user = mentions.find((mention) => mention.id === userId);
- if (!user) return token;
- return `@${user.member?.nick || user.global_name || user.username}`;
- });
-}
-
export function buildWireMessageNotificationBody(message: WireMessage, i18n: I18n): string {
const markdownOptions: MarkdownPreviewOptions = {
channelId: message.channel_id,
mentionChannels: message.mention_channels,
+ resolveFromStores: false,
i18n,
};
- const userBody = renderMarkdownPreview(inlineUserMentions(message.content, message.mentions), markdownOptions);
+ const userBody = renderMarkdownPreview(inlineMentionedUserNames(message.content, message.mentions), markdownOptions);
if (userBody) return userBody;
const contentFallback = buildMessageContentFallbackPreview(
{