435 lines
19 KiB
TypeScript
435 lines
19 KiB
TypeScript
/*
|
|
Copyright 2024 New Vector Ltd.
|
|
Copyright 2020, 2021 The Matrix.org Foundation C.I.C.
|
|
|
|
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
|
|
Please see LICENSE files in the repository root for full details.
|
|
*/
|
|
|
|
import {
|
|
Capability,
|
|
EventDirection,
|
|
EventKind,
|
|
getTimelineRoomIDFromCapability,
|
|
isTimelineCapability,
|
|
isTimelineCapabilityFor,
|
|
MatrixCapabilities,
|
|
Symbols,
|
|
WidgetEventCapability,
|
|
WidgetKind,
|
|
} from "matrix-widget-api";
|
|
import { EventType, MsgType } from "matrix-js-sdk/src/matrix";
|
|
import React from "react";
|
|
|
|
import { _t, _td, TranslatedString, TranslationKey } from "../languageHandler";
|
|
import { ElementWidgetCapabilities } from "../stores/widgets/ElementWidgetCapabilities";
|
|
import { MatrixClientPeg } from "../MatrixClientPeg";
|
|
import TextWithTooltip from "../components/views/elements/TextWithTooltip";
|
|
|
|
type GENERIC_WIDGET_KIND = "generic"; // eslint-disable-line @typescript-eslint/naming-convention
|
|
const GENERIC_WIDGET_KIND: GENERIC_WIDGET_KIND = "generic";
|
|
|
|
type SendRecvStaticCapText = Partial<
|
|
Record<
|
|
EventType | string,
|
|
Partial<Record<WidgetKind | GENERIC_WIDGET_KIND, Record<EventDirection, TranslationKey>>>
|
|
>
|
|
>;
|
|
|
|
export interface TranslatedCapabilityText {
|
|
primary: TranslatedString;
|
|
byline?: TranslatedString;
|
|
}
|
|
|
|
export class CapabilityText {
|
|
private static simpleCaps: Record<Capability, Partial<Record<WidgetKind | GENERIC_WIDGET_KIND, TranslationKey>>> = {
|
|
[MatrixCapabilities.AlwaysOnScreen]: {
|
|
[WidgetKind.Room]: _td("widget|capability|always_on_screen_viewing_another_room"),
|
|
[GENERIC_WIDGET_KIND]: _td("widget|capability|always_on_screen_generic"),
|
|
},
|
|
[MatrixCapabilities.StickerSending]: {
|
|
[WidgetKind.Room]: _td("widget|capability|send_stickers_this_room"),
|
|
[GENERIC_WIDGET_KIND]: _td("widget|capability|send_stickers_active_room"),
|
|
},
|
|
[ElementWidgetCapabilities.CanChangeViewedRoom]: {
|
|
[GENERIC_WIDGET_KIND]: _td("widget|capability|switch_room"),
|
|
},
|
|
[MatrixCapabilities.MSC2931Navigate]: {
|
|
[GENERIC_WIDGET_KIND]: _td("widget|capability|switch_room_message_user"),
|
|
},
|
|
};
|
|
|
|
private static stateSendRecvCaps: SendRecvStaticCapText = {
|
|
[EventType.RoomTopic]: {
|
|
[WidgetKind.Room]: {
|
|
[EventDirection.Send]: _td("widget|capability|change_topic_this_room"),
|
|
[EventDirection.Receive]: _td("widget|capability|see_topic_change_this_room"),
|
|
},
|
|
[GENERIC_WIDGET_KIND]: {
|
|
[EventDirection.Send]: _td("widget|capability|change_topic_active_room"),
|
|
[EventDirection.Receive]: _td("widget|capability|see_topic_change_active_room"),
|
|
},
|
|
},
|
|
[EventType.RoomName]: {
|
|
[WidgetKind.Room]: {
|
|
[EventDirection.Send]: _td("widget|capability|change_name_this_room"),
|
|
[EventDirection.Receive]: _td("widget|capability|see_name_change_this_room"),
|
|
},
|
|
[GENERIC_WIDGET_KIND]: {
|
|
[EventDirection.Send]: _td("widget|capability|change_name_active_room"),
|
|
[EventDirection.Receive]: _td("widget|capability|see_name_change_active_room"),
|
|
},
|
|
},
|
|
[EventType.RoomAvatar]: {
|
|
[WidgetKind.Room]: {
|
|
[EventDirection.Send]: _td("widget|capability|change_avatar_this_room"),
|
|
[EventDirection.Receive]: _td("widget|capability|see_avatar_change_this_room"),
|
|
},
|
|
[GENERIC_WIDGET_KIND]: {
|
|
[EventDirection.Send]: _td("widget|capability|change_avatar_active_room"),
|
|
[EventDirection.Receive]: _td("widget|capability|see_avatar_change_active_room"),
|
|
},
|
|
},
|
|
[EventType.RoomMember]: {
|
|
[WidgetKind.Room]: {
|
|
[EventDirection.Send]: _td("widget|capability|remove_ban_invite_leave_this_room"),
|
|
[EventDirection.Receive]: _td("widget|capability|receive_membership_this_room"),
|
|
},
|
|
[GENERIC_WIDGET_KIND]: {
|
|
[EventDirection.Send]: _td("widget|capability|remove_ban_invite_leave_active_room"),
|
|
[EventDirection.Receive]: _td("widget|capability|receive_membership_active_room"),
|
|
},
|
|
},
|
|
};
|
|
|
|
private static nonStateSendRecvCaps: SendRecvStaticCapText = {
|
|
[EventType.Sticker]: {
|
|
[WidgetKind.Room]: {
|
|
[EventDirection.Send]: _td("widget|capability|send_stickers_this_room_as_you"),
|
|
[EventDirection.Receive]: _td("widget|capability|see_sticker_posted_this_room"),
|
|
},
|
|
[GENERIC_WIDGET_KIND]: {
|
|
[EventDirection.Send]: _td("widget|capability|send_stickers_active_room_as_you"),
|
|
[EventDirection.Receive]: _td("widget|capability|see_sticker_posted_active_room"),
|
|
},
|
|
},
|
|
};
|
|
|
|
private static bylineFor(eventCap: WidgetEventCapability): TranslatedString {
|
|
if (eventCap.kind === EventKind.State) {
|
|
return !eventCap.keyStr
|
|
? _t("widget|capability|byline_empty_state_key")
|
|
: _t("widget|capability|byline_state_key", { stateKey: eventCap.keyStr });
|
|
}
|
|
return null; // room messages are handled specially
|
|
}
|
|
|
|
public static for(capability: Capability, kind: WidgetKind): TranslatedCapabilityText {
|
|
// TODO: Support MSC3819 (to-device capabilities)
|
|
|
|
// First see if we have a super simple line of text to provide back
|
|
if (CapabilityText.simpleCaps[capability]) {
|
|
const textForKind = CapabilityText.simpleCaps[capability];
|
|
if (textForKind[kind]) return { primary: _t(textForKind[kind]!) };
|
|
if (textForKind[GENERIC_WIDGET_KIND]) return { primary: _t(textForKind[GENERIC_WIDGET_KIND]) };
|
|
|
|
// ... we'll fall through to the generic capability processing at the end of this
|
|
// function if we fail to generate a string for the capability.
|
|
}
|
|
|
|
// Try to handle timeline capabilities. The text here implies that the caller has sorted
|
|
// the timeline caps to the end for UI purposes.
|
|
if (isTimelineCapability(capability)) {
|
|
if (isTimelineCapabilityFor(capability, Symbols.AnyRoom)) {
|
|
return { primary: _t("widget|capability|any_room") };
|
|
} else {
|
|
const roomId = getTimelineRoomIDFromCapability(capability);
|
|
const room = MatrixClientPeg.safeGet().getRoom(roomId);
|
|
return {
|
|
primary: _t(
|
|
"widget|capability|specific_room",
|
|
{},
|
|
{
|
|
Room: () => {
|
|
if (room) {
|
|
return (
|
|
<TextWithTooltip tooltip={room.getCanonicalAlias() ?? roomId}>
|
|
<b>{room.name}</b>
|
|
</TextWithTooltip>
|
|
);
|
|
} else {
|
|
return (
|
|
<b>
|
|
<code>{roomId}</code>
|
|
</b>
|
|
);
|
|
}
|
|
},
|
|
},
|
|
),
|
|
};
|
|
}
|
|
}
|
|
|
|
// We didn't have a super simple line of text, so try processing the capability as the
|
|
// more complex event send/receive permission type.
|
|
const [eventCap] = WidgetEventCapability.findEventCapabilities([capability]);
|
|
if (eventCap) {
|
|
// Special case room messages so they show up a bit cleaner to the user. Result is
|
|
// effectively "Send images" instead of "Send messages... of type images" if we were
|
|
// to handle the msgtype nuances in this function.
|
|
if (eventCap.kind === EventKind.Event && eventCap.eventType === EventType.RoomMessage) {
|
|
return CapabilityText.forRoomMessageCap(eventCap, kind);
|
|
}
|
|
|
|
// See if we have a static line of text to provide for the given event type and
|
|
// direction. The hope is that we do for common event types for friendlier copy.
|
|
const evSendRecv =
|
|
eventCap.kind === EventKind.State
|
|
? CapabilityText.stateSendRecvCaps
|
|
: CapabilityText.nonStateSendRecvCaps;
|
|
if (evSendRecv[eventCap.eventType]) {
|
|
const textForKind = evSendRecv[eventCap.eventType];
|
|
const textForDirection = textForKind?.[kind] || textForKind?.[GENERIC_WIDGET_KIND];
|
|
if (textForDirection?.[eventCap.direction]) {
|
|
return {
|
|
primary: _t(textForDirection[eventCap.direction]),
|
|
// no byline because we would have already represented the event properly
|
|
};
|
|
}
|
|
}
|
|
|
|
// We don't have anything simple, so just return a generic string for the event cap
|
|
if (kind === WidgetKind.Room) {
|
|
if (eventCap.direction === EventDirection.Send) {
|
|
return {
|
|
primary: _t(
|
|
"widget|capability|send_event_type_this_room",
|
|
{
|
|
eventType: eventCap.eventType,
|
|
},
|
|
{
|
|
b: (sub) => <b>{sub}</b>,
|
|
},
|
|
),
|
|
byline: CapabilityText.bylineFor(eventCap),
|
|
};
|
|
} else {
|
|
return {
|
|
primary: _t(
|
|
"widget|capability|see_event_type_sent_this_room",
|
|
{
|
|
eventType: eventCap.eventType,
|
|
},
|
|
{
|
|
b: (sub) => <b>{sub}</b>,
|
|
},
|
|
),
|
|
byline: CapabilityText.bylineFor(eventCap),
|
|
};
|
|
}
|
|
} else {
|
|
// assume generic
|
|
if (eventCap.direction === EventDirection.Send) {
|
|
return {
|
|
primary: _t(
|
|
"widget|capability|send_event_type_active_room",
|
|
{
|
|
eventType: eventCap.eventType,
|
|
},
|
|
{
|
|
b: (sub) => <b>{sub}</b>,
|
|
},
|
|
),
|
|
byline: CapabilityText.bylineFor(eventCap),
|
|
};
|
|
} else {
|
|
return {
|
|
primary: _t(
|
|
"widget|capability|see_event_type_sent_active_room",
|
|
{
|
|
eventType: eventCap.eventType,
|
|
},
|
|
{
|
|
b: (sub) => <b>{sub}</b>,
|
|
},
|
|
),
|
|
byline: CapabilityText.bylineFor(eventCap),
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
// We don't have enough context to render this capability specially, so we'll present it as-is
|
|
return {
|
|
primary: _t(
|
|
"widget|capability|capability",
|
|
{ capability },
|
|
{
|
|
b: (sub) => <b>{sub}</b>,
|
|
},
|
|
),
|
|
};
|
|
}
|
|
|
|
private static forRoomMessageCap(eventCap: WidgetEventCapability, kind: WidgetKind): TranslatedCapabilityText {
|
|
// First handle the case of "all messages" to make the switch later on a bit clearer
|
|
if (!eventCap.keyStr) {
|
|
if (eventCap.direction === EventDirection.Send) {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|send_messages_this_room")
|
|
: _t("widget|capability|send_messages_active_room"),
|
|
};
|
|
} else {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|see_messages_sent_this_room")
|
|
: _t("widget|capability|see_messages_sent_active_room"),
|
|
};
|
|
}
|
|
}
|
|
|
|
// Now handle all the message types we care about. There are more message types available, however
|
|
// they are not as common so we don't bother rendering them. They'll fall into the generic case.
|
|
switch (eventCap.keyStr) {
|
|
case MsgType.Text: {
|
|
if (eventCap.direction === EventDirection.Send) {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|send_text_messages_this_room")
|
|
: _t("widget|capability|send_text_messages_active_room"),
|
|
};
|
|
} else {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|see_text_messages_sent_this_room")
|
|
: _t("widget|capability|see_text_messages_sent_active_room"),
|
|
};
|
|
}
|
|
}
|
|
case MsgType.Emote: {
|
|
if (eventCap.direction === EventDirection.Send) {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|send_emotes_this_room")
|
|
: _t("widget|capability|send_emotes_active_room"),
|
|
};
|
|
} else {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|see_sent_emotes_this_room")
|
|
: _t("widget|capability|see_sent_emotes_active_room"),
|
|
};
|
|
}
|
|
}
|
|
case MsgType.Image: {
|
|
if (eventCap.direction === EventDirection.Send) {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|send_images_this_room")
|
|
: _t("widget|capability|send_images_active_room"),
|
|
};
|
|
} else {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|see_images_sent_this_room")
|
|
: _t("widget|capability|see_images_sent_active_room"),
|
|
};
|
|
}
|
|
}
|
|
case MsgType.Video: {
|
|
if (eventCap.direction === EventDirection.Send) {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|send_videos_this_room")
|
|
: _t("widget|capability|send_videos_active_room"),
|
|
};
|
|
} else {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|see_videos_sent_this_room")
|
|
: _t("widget|capability|see_videos_sent_active_room"),
|
|
};
|
|
}
|
|
}
|
|
case MsgType.File: {
|
|
if (eventCap.direction === EventDirection.Send) {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|send_files_this_room")
|
|
: _t("widget|capability|send_files_active_room"),
|
|
};
|
|
} else {
|
|
return {
|
|
primary:
|
|
kind === WidgetKind.Room
|
|
? _t("widget|capability|see_sent_files_this_room")
|
|
: _t("widget|capability|see_sent_files_active_room"),
|
|
};
|
|
}
|
|
}
|
|
default: {
|
|
let primary: TranslatedString;
|
|
if (eventCap.direction === EventDirection.Send) {
|
|
if (kind === WidgetKind.Room) {
|
|
primary = _t(
|
|
"widget|capability|send_msgtype_this_room",
|
|
{
|
|
msgtype: eventCap.keyStr,
|
|
},
|
|
{
|
|
b: (sub) => <b>{sub}</b>,
|
|
},
|
|
);
|
|
} else {
|
|
primary = _t(
|
|
"widget|capability|send_msgtype_active_room",
|
|
{
|
|
msgtype: eventCap.keyStr,
|
|
},
|
|
{
|
|
b: (sub) => <b>{sub}</b>,
|
|
},
|
|
);
|
|
}
|
|
} else {
|
|
if (kind === WidgetKind.Room) {
|
|
primary = _t(
|
|
"widget|capability|see_msgtype_sent_this_room",
|
|
{
|
|
msgtype: eventCap.keyStr,
|
|
},
|
|
{
|
|
b: (sub) => <b>{sub}</b>,
|
|
},
|
|
);
|
|
} else {
|
|
primary = _t(
|
|
"widget|capability|see_msgtype_sent_active_room",
|
|
{
|
|
msgtype: eventCap.keyStr,
|
|
},
|
|
{
|
|
b: (sub) => <b>{sub}</b>,
|
|
},
|
|
);
|
|
}
|
|
}
|
|
return { primary };
|
|
}
|
|
}
|
|
}
|
|
}
|