matrix-react-sdk
Version:
SDK for matrix.org using React
167 lines (161 loc) • 25.8 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.MainGrouper = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _react = _interopRequireDefault(require("react"));
var _matrix = require("matrix-js-sdk/src/matrix");
var _BaseGrouper = require("./BaseGrouper");
var _TextForEvent = require("../../../TextForEvent");
var _MatrixClientPeg = require("../../../MatrixClientPeg");
var _DateSeparator = _interopRequireDefault(require("../../views/messages/DateSeparator"));
var _HistoryTile = _interopRequireDefault(require("../../views/rooms/HistoryTile"));
var _EventListSummary = _interopRequireDefault(require("../../views/elements/EventListSummary"));
var _TimelineSeparator = require("../../views/messages/TimelineSeparator");
/*
Copyright 2024 New Vector Ltd.
Copyright 2023 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.
*/
const groupedStateEvents = [_matrix.EventType.RoomMember, _matrix.EventType.RoomThirdPartyInvite, _matrix.EventType.RoomServerAcl, _matrix.EventType.RoomPinnedEvents];
// Wrap consecutive grouped events in a ListSummary
class MainGrouper extends _BaseGrouper.BaseGrouper {
constructor(panel, firstEventAndShouldShow, prevEvent, lastShownEvent, nextEvent, nextEventTile) {
super(panel, firstEventAndShouldShow, prevEvent, lastShownEvent, nextEvent, nextEventTile);
this.panel = panel;
this.firstEventAndShouldShow = firstEventAndShouldShow;
this.prevEvent = prevEvent;
this.lastShownEvent = lastShownEvent;
this.events = [firstEventAndShouldShow];
}
shouldGroup({
event: ev,
shouldShow
}) {
if (!shouldShow) {
// absorb hidden events so that they do not break up streams of messages & redaction events being grouped
return true;
}
if (this.panel.wantsSeparator(this.events[0].event, ev) === _TimelineSeparator.SeparatorKind.Date) {
return false;
}
if (ev.isState() && groupedStateEvents.includes(ev.getType())) {
return true;
}
if (ev.isRedacted()) {
return true;
}
if (this.panel.showHiddenEvents && !this.panel.shouldShowEvent(ev, true)) {
return true;
}
return false;
}
add(wrappedEvent) {
const {
event: ev,
shouldShow
} = wrappedEvent;
if (ev.getType() === _matrix.EventType.RoomMember) {
// We can ignore any events that don't actually have a message to display
if (!(0, _TextForEvent.hasText)(ev, _MatrixClientPeg.MatrixClientPeg.safeGet(), this.panel.showHiddenEvents)) return;
}
this.readMarker = this.readMarker || this.panel.readMarkerForEvent(ev.getId(), ev === this.lastShownEvent);
if (!this.panel.showHiddenEvents && !shouldShow) {
// absorb hidden events to not split the summary
return;
}
if (ev.getType() === _matrix.EventType.RoomPinnedEvents) {
// If pinned messages are disabled, don't show the summary
return;
}
this.events.push(wrappedEvent);
}
generateKey() {
return "eventlistsummary-" + this.events[0].event.getId();
}
getTiles() {
// If we don't have any events to group, don't even try to group them. The logic
// below assumes that we have a group of events to deal with, but we might not if
// the events we were supposed to group were redacted.
if (!this.events?.length) return [];
const isGrouped = true;
const panel = this.panel;
const lastShownEvent = this.lastShownEvent;
const ret = [];
if (panel.wantsSeparator(this.prevEvent, this.events[0].event) === _TimelineSeparator.SeparatorKind.Date) {
const ts = this.events[0].event.getTs();
ret.push( /*#__PURE__*/_react.default.createElement("li", {
key: ts + "~"
}, /*#__PURE__*/_react.default.createElement(_DateSeparator.default, {
roomId: this.events[0].event.getRoomId(),
ts: ts
})));
}
// Ensure that the key of the EventListSummary does not change with new events in either direction.
// This will prevent it from being re-created unnecessarily, and instead will allow new props to be provided.
// In turn, the shouldComponentUpdate method on ELS can be used to prevent unnecessary renderings.
const keyEvent = this.events.find(e => this.panel.grouperKeyMap.get(e.event));
const key = keyEvent && this.panel.grouperKeyMap.has(keyEvent.event) ? this.panel.grouperKeyMap.get(keyEvent.event) : this.generateKey();
if (!keyEvent) {
// Populate the weak map with the key.
// Note that we only set the key on the specific event it refers to, since this group might get
// split up in the future by other intervening events. If we were to set the key on all events
// currently in the group, we would risk later giving the same key to multiple groups.
this.panel.grouperKeyMap.set(this.events[0].event, key);
}
let highlightInSummary = false;
let eventTiles = this.events.map((e, i) => {
if (e.event.getId() === panel.props.highlightedEventId) {
highlightInSummary = true;
}
return panel.getTilesForEvent(i === 0 ? this.prevEvent : this.events[i - 1].event, e, e.event === lastShownEvent, isGrouped, this.nextEvent, this.nextEventTile);
}).reduce((a, b) => a.concat(b), []);
if (eventTiles.length === 0) {
eventTiles = null;
}
// If a membership event is the start of visible history, tell the user
// why they can't see earlier messages
if (!this.panel.props.canBackPaginate && !this.prevEvent) {
ret.push( /*#__PURE__*/_react.default.createElement(_HistoryTile.default, {
key: "historytile"
}));
}
ret.push( /*#__PURE__*/_react.default.createElement(_EventListSummary.default, {
key: key,
"data-testid": key,
events: this.events.map(e => e.event),
onToggle: panel.onHeightChanged // Update scroll state
,
startExpanded: highlightInSummary,
layout: this.panel.props.layout
}, eventTiles));
if (this.readMarker) {
ret.push(this.readMarker);
}
return ret;
}
getNewPrevEvent() {
return this.events[this.events.length - 1].event;
}
}
exports.MainGrouper = MainGrouper;
(0, _defineProperty2.default)(MainGrouper, "canStartGroup", function (panel, {
event: ev,
shouldShow
}) {
if (!shouldShow) return false;
if (ev.isState() && groupedStateEvents.includes(ev.getType())) {
return true;
}
if (ev.isRedacted()) {
return true;
}
if (panel.showHiddenEvents && !panel.shouldShowEvent(ev, true)) {
return true;
}
return false;
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_matrix","_BaseGrouper","_TextForEvent","_MatrixClientPeg","_DateSeparator","_HistoryTile","_EventListSummary","_TimelineSeparator","groupedStateEvents","EventType","RoomMember","RoomThirdPartyInvite","RoomServerAcl","RoomPinnedEvents","MainGrouper","BaseGrouper","constructor","panel","firstEventAndShouldShow","prevEvent","lastShownEvent","nextEvent","nextEventTile","events","shouldGroup","event","ev","shouldShow","wantsSeparator","SeparatorKind","Date","isState","includes","getType","isRedacted","showHiddenEvents","shouldShowEvent","add","wrappedEvent","hasText","MatrixClientPeg","safeGet","readMarker","readMarkerForEvent","getId","push","generateKey","getTiles","length","isGrouped","ret","ts","getTs","default","createElement","key","roomId","getRoomId","keyEvent","find","e","grouperKeyMap","get","has","set","highlightInSummary","eventTiles","map","i","props","highlightedEventId","getTilesForEvent","reduce","a","b","concat","canBackPaginate","onToggle","onHeightChanged","startExpanded","layout","getNewPrevEvent","exports","_defineProperty2"],"sources":["../../../../src/components/structures/grouper/MainGrouper.tsx"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, { ReactNode } from \"react\";\nimport { EventType, MatrixEvent } from \"matrix-js-sdk/src/matrix\";\n\nimport type MessagePanel from \"../MessagePanel\";\nimport type { WrappedEvent } from \"../MessagePanel\";\nimport { BaseGrouper } from \"./BaseGrouper\";\nimport { hasText } from \"../../../TextForEvent\";\nimport { MatrixClientPeg } from \"../../../MatrixClientPeg\";\nimport DateSeparator from \"../../views/messages/DateSeparator\";\nimport HistoryTile from \"../../views/rooms/HistoryTile\";\nimport EventListSummary from \"../../views/elements/EventListSummary\";\nimport { SeparatorKind } from \"../../views/messages/TimelineSeparator\";\n\nconst groupedStateEvents = [\n    EventType.RoomMember,\n    EventType.RoomThirdPartyInvite,\n    EventType.RoomServerAcl,\n    EventType.RoomPinnedEvents,\n];\n\n// Wrap consecutive grouped events in a ListSummary\nexport class MainGrouper extends BaseGrouper {\n    public static canStartGroup = function (panel: MessagePanel, { event: ev, shouldShow }: WrappedEvent): boolean {\n        if (!shouldShow) return false;\n\n        if (ev.isState() && groupedStateEvents.includes(ev.getType() as EventType)) {\n            return true;\n        }\n\n        if (ev.isRedacted()) {\n            return true;\n        }\n\n        if (panel.showHiddenEvents && !panel.shouldShowEvent(ev, true)) {\n            return true;\n        }\n\n        return false;\n    };\n\n    public constructor(\n        public readonly panel: MessagePanel,\n        public readonly firstEventAndShouldShow: WrappedEvent,\n        public readonly prevEvent: MatrixEvent | null,\n        public readonly lastShownEvent: MatrixEvent | undefined,\n        nextEvent: WrappedEvent | null,\n        nextEventTile: MatrixEvent | null,\n    ) {\n        super(panel, firstEventAndShouldShow, prevEvent, lastShownEvent, nextEvent, nextEventTile);\n        this.events = [firstEventAndShouldShow];\n    }\n\n    public shouldGroup({ event: ev, shouldShow }: WrappedEvent): boolean {\n        if (!shouldShow) {\n            // absorb hidden events so that they do not break up streams of messages & redaction events being grouped\n            return true;\n        }\n        if (this.panel.wantsSeparator(this.events[0].event, ev) === SeparatorKind.Date) {\n            return false;\n        }\n        if (ev.isState() && groupedStateEvents.includes(ev.getType() as EventType)) {\n            return true;\n        }\n        if (ev.isRedacted()) {\n            return true;\n        }\n        if (this.panel.showHiddenEvents && !this.panel.shouldShowEvent(ev, true)) {\n            return true;\n        }\n        return false;\n    }\n\n    public add(wrappedEvent: WrappedEvent): void {\n        const { event: ev, shouldShow } = wrappedEvent;\n        if (ev.getType() === EventType.RoomMember) {\n            // We can ignore any events that don't actually have a message to display\n            if (!hasText(ev, MatrixClientPeg.safeGet(), this.panel.showHiddenEvents)) return;\n        }\n        this.readMarker = this.readMarker || this.panel.readMarkerForEvent(ev.getId()!, ev === this.lastShownEvent);\n        if (!this.panel.showHiddenEvents && !shouldShow) {\n            // absorb hidden events to not split the summary\n            return;\n        }\n\n        if (ev.getType() === EventType.RoomPinnedEvents) {\n            // If pinned messages are disabled, don't show the summary\n            return;\n        }\n\n        this.events.push(wrappedEvent);\n    }\n\n    private generateKey(): string {\n        return \"eventlistsummary-\" + this.events[0].event.getId();\n    }\n\n    public getTiles(): ReactNode[] {\n        // If we don't have any events to group, don't even try to group them. The logic\n        // below assumes that we have a group of events to deal with, but we might not if\n        // the events we were supposed to group were redacted.\n        if (!this.events?.length) return [];\n\n        const isGrouped = true;\n        const panel = this.panel;\n        const lastShownEvent = this.lastShownEvent;\n        const ret: ReactNode[] = [];\n\n        if (panel.wantsSeparator(this.prevEvent, this.events[0].event) === SeparatorKind.Date) {\n            const ts = this.events[0].event.getTs();\n            ret.push(\n                <li key={ts + \"~\"}>\n                    <DateSeparator roomId={this.events[0].event.getRoomId()!} ts={ts} />\n                </li>,\n            );\n        }\n\n        // Ensure that the key of the EventListSummary does not change with new events in either direction.\n        // This will prevent it from being re-created unnecessarily, and instead will allow new props to be provided.\n        // In turn, the shouldComponentUpdate method on ELS can be used to prevent unnecessary renderings.\n        const keyEvent = this.events.find((e) => this.panel.grouperKeyMap.get(e.event));\n        const key =\n            keyEvent && this.panel.grouperKeyMap.has(keyEvent.event)\n                ? this.panel.grouperKeyMap.get(keyEvent.event)!\n                : this.generateKey();\n        if (!keyEvent) {\n            // Populate the weak map with the key.\n            // Note that we only set the key on the specific event it refers to, since this group might get\n            // split up in the future by other intervening events. If we were to set the key on all events\n            // currently in the group, we would risk later giving the same key to multiple groups.\n            this.panel.grouperKeyMap.set(this.events[0].event, key);\n        }\n\n        let highlightInSummary = false;\n        let eventTiles: ReactNode[] | null = this.events\n            .map((e, i) => {\n                if (e.event.getId() === panel.props.highlightedEventId) {\n                    highlightInSummary = true;\n                }\n                return panel.getTilesForEvent(\n                    i === 0 ? this.prevEvent : this.events[i - 1].event,\n                    e,\n                    e.event === lastShownEvent,\n                    isGrouped,\n                    this.nextEvent,\n                    this.nextEventTile,\n                );\n            })\n            .reduce((a, b) => a.concat(b), []);\n\n        if (eventTiles.length === 0) {\n            eventTiles = null;\n        }\n\n        // If a membership event is the start of visible history, tell the user\n        // why they can't see earlier messages\n        if (!this.panel.props.canBackPaginate && !this.prevEvent) {\n            ret.push(<HistoryTile key=\"historytile\" />);\n        }\n\n        ret.push(\n            <EventListSummary\n                key={key}\n                data-testid={key}\n                events={this.events.map((e) => e.event)}\n                onToggle={panel.onHeightChanged} // Update scroll state\n                startExpanded={highlightInSummary}\n                layout={this.panel.props.layout}\n            >\n                {eventTiles}\n            </EventListSummary>,\n        );\n\n        if (this.readMarker) {\n            ret.push(this.readMarker);\n        }\n\n        return ret;\n    }\n\n    public getNewPrevEvent(): MatrixEvent {\n        return this.events[this.events.length - 1].event;\n    }\n}\n"],"mappings":"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","ignoreList":[]}