matrix-react-sdk/lib/components/structures/MessagePanel.js

SDK for matrix.org using React

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
exports.shouldFormContinuation = shouldFormContinuation;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _react = _interopRequireWildcard(require("react"));
var _reactDom = _interopRequireDefault(require("react-dom"));
var _classnames = _interopRequireDefault(require("classnames"));
var _matrix = require("matrix-js-sdk/src/matrix");
var _logger = require("matrix-js-sdk/src/logger");
var _utils = require("matrix-js-sdk/src/utils");
var _shouldHideEvent = _interopRequireDefault(require("../../shouldHideEvent"));
var _DateUtils = require("../../DateUtils");
var _MatrixClientPeg = require("../../MatrixClientPeg");
var _SettingsStore = _interopRequireDefault(require("../../settings/SettingsStore"));
var _RoomContext = _interopRequireWildcard(require("../../contexts/RoomContext"));
var _Layout = require("../../settings/enums/Layout");
var _EventTile = _interopRequireWildcard(require("../views/rooms/EventTile"));
var _IRCTimelineProfileResizer = _interopRequireDefault(require("../views/elements/IRCTimelineProfileResizer"));
var _dispatcher = _interopRequireDefault(require("../../dispatcher/dispatcher"));
var _WhoIsTypingTile = _interopRequireDefault(require("../views/rooms/WhoIsTypingTile"));
var _ScrollPanel = _interopRequireDefault(require("./ScrollPanel"));
var _DateSeparator = _interopRequireDefault(require("../views/messages/DateSeparator"));
var _TimelineSeparator = _interopRequireWildcard(require("../views/messages/TimelineSeparator"));
var _ErrorBoundary = _interopRequireDefault(require("../views/elements/ErrorBoundary"));
var _Spinner = _interopRequireDefault(require("../views/elements/Spinner"));
var _actions = require("../../dispatcher/actions");
var _EventRenderingUtils = require("../../utils/EventRenderingUtils");
var _EventTileFactory = require("../../events/EventTileFactory");
var _Editing = require("../../Editing");
var _EventUtils = require("../../utils/EventUtils");
var _MainGrouper = require("./grouper/MainGrouper");
var _CreationGrouper = require("./grouper/CreationGrouper");
var _languageHandler = require("../../languageHandler");
var _LateEventGrouper = require("./grouper/LateEventGrouper");
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
/*
Copyright 2024 New Vector Ltd.
Copyright 2016-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 CONTINUATION_MAX_INTERVAL = 5 * 60 * 1000; // 5 minutes
const continuedTypes = [_matrix.EventType.Sticker, _matrix.EventType.RoomMessage];

// check if there is a previous event and it has the same sender as this event
// and the types are the same/is in continuedTypes and the time between them is <= CONTINUATION_MAX_INTERVAL
function shouldFormContinuation(prevEvent, mxEvent, matrixClient, showHiddenEvents, timelineRenderingType) {
  if (timelineRenderingType === _RoomContext.TimelineRenderingType.ThreadsList) return false;
  // sanity check inputs
  if (!prevEvent?.sender || !mxEvent.sender) return false;
  // check if within the max continuation period
  if (mxEvent.getTs() - prevEvent.getTs() > CONTINUATION_MAX_INTERVAL) return false;

  // As we summarise redactions, do not continue a redacted event onto a non-redacted one and vice-versa
  if (mxEvent.isRedacted() !== prevEvent.isRedacted()) return false;

  // Some events should appear as continuations from previous events of different types.
  if (mxEvent.getType() !== prevEvent.getType() && (!continuedTypes.includes(mxEvent.getType()) || !continuedTypes.includes(prevEvent.getType()))) return false;

  // Check if the sender is the same and hasn't changed their displayname/avatar between these events
  if (mxEvent.sender.userId !== prevEvent.sender.userId || mxEvent.sender.name !== prevEvent.sender.name || mxEvent.sender.getMxcAvatarUrl() !== prevEvent.sender.getMxcAvatarUrl()) return false;

  // Thread summaries in the main timeline should break up a continuation on both sides
  if (((0, _EventUtils.hasThreadSummary)(mxEvent) || (0, _EventUtils.hasThreadSummary)(prevEvent)) && timelineRenderingType !== _RoomContext.TimelineRenderingType.Thread) {
    return false;
  }

  // if we don't have tile for previous event then it was shown by showHiddenEvents and has no SenderProfile
  if (!(0, _EventTileFactory.haveRendererForEvent)(prevEvent, matrixClient, showHiddenEvents)) return false;
  return true;
}
/* (almost) stateless UI component which builds the event tiles in the room timeline.
 */
class MessagePanel extends _react.default.Component {
  constructor(props, context) {
    super(props, context);
    // opaque readreceipt info for each userId; used by ReadReceiptMarker
    // to manage its animations
    (0, _defineProperty2.default)(this, "readReceiptMap", {});
    // Track read receipts by event ID. For each _shown_ event ID, we store
    // the list of read receipts to display:
    //   [
    //       {
    //           userId: string,
    //           member: RoomMember,
    //           ts: number,
    //       },
    //   ]
    // This is recomputed on each render. It's only stored on the component
    // for ease of passing the data around since it's computed in one pass
    // over all events.
    (0, _defineProperty2.default)(this, "readReceiptsByEvent", new Map());
    // Track read receipts by user ID. For each user ID we've ever shown a
    // a read receipt for, we store an object:
    //   {
    //       lastShownEventId: string,
    //       receipt: {
    //           userId: string,
    //           member: RoomMember,
    //           ts: number,
    //       },
    //   }
    // so that we can always keep receipts displayed by reverting back to
    // the last shown event for that user ID when needed. This may feel like
    // it duplicates the receipt storage in the room, but at this layer, we
    // are tracking _shown_ event IDs, which the JS SDK knows nothing about.
    // This is recomputed on each render, using the data from the previous
    // render as our fallback for any user IDs we can't match a receipt to a
    // displayed event in the current render cycle.
    (0, _defineProperty2.default)(this, "readReceiptsByUserId", new Map());
    (0, _defineProperty2.default)(this, "_showHiddenEvents", void 0);
    (0, _defineProperty2.default)(this, "isMounted", false);
    (0, _defineProperty2.default)(this, "readMarkerNode", /*#__PURE__*/(0, _react.createRef)());
    (0, _defineProperty2.default)(this, "whoIsTyping", /*#__PURE__*/(0, _react.createRef)());
    (0, _defineProperty2.default)(this, "scrollPanel", /*#__PURE__*/(0, _react.createRef)());
    (0, _defineProperty2.default)(this, "showTypingNotificationsWatcherRef", void 0);
    (0, _defineProperty2.default)(this, "eventTiles", {});
    // A map to allow groupers to maintain consistent keys even if their first event is uprooted due to back-pagination.
    (0, _defineProperty2.default)(this, "grouperKeyMap", new WeakMap());
    (0, _defineProperty2.default)(this, "calculateRoomMembersCount", () => {
      this.setState({
        hideSender: this.shouldHideSender()
      });
    });
    (0, _defineProperty2.default)(this, "onShowTypingNotificationsChange", () => {
      this.setState({
        showTypingNotifications: _SettingsStore.default.getValue("showTypingNotifications")
      });
    });
    (0, _defineProperty2.default)(this, "isUnmounting", () => {
      return !this.isMounted;
    });
    (0, _defineProperty2.default)(this, "collectGhostReadMarker", node => {
      if (node) {
        // now the element has appeared, change the style which will trigger the CSS transition
        requestAnimationFrame(() => {
          node.style.width = "10%";
          node.style.opacity = "0";
        });
      }
    });
    (0, _defineProperty2.default)(this, "onGhostTransitionEnd", ev => {
      // we can now clean up the ghost element
      const finishedEventId = ev.target.dataset.eventid;
      this.setState({
        ghostReadMarkers: this.state.ghostReadMarkers.filter(eid => eid !== finishedEventId)
      });
    });
    (0, _defineProperty2.default)(this, "collectEventTile", (eventId, node) => {
      this.eventTiles[eventId] = node;
    });
    // once dynamic content in the events load, make the scrollPanel check the
    // scroll offsets.
    (0, _defineProperty2.default)(this, "onHeightChanged", () => {
      const scrollPanel = this.scrollPanel.current;
      if (scrollPanel) {
        scrollPanel.checkScroll();
      }
    });
    (0, _defineProperty2.default)(this, "onTypingShown", () => {
      const scrollPanel = this.scrollPanel.current;
      // this will make the timeline grow, so checkScroll
      scrollPanel?.checkScroll();
      if (scrollPanel && scrollPanel.getScrollState().stuckAtBottom) {
        scrollPanel.preventShrinking();
      }
    });
    (0, _defineProperty2.default)(this, "onTypingHidden", () => {
      const scrollPanel = this.scrollPanel.current;
      if (scrollPanel) {
        // as hiding the typing notifications doesn't
        // update the scrollPanel, we tell it to apply
        // the shrinking prevention once the typing notifs are hidden
        scrollPanel.updatePreventShrinking();
        // order is important here as checkScroll will scroll down to
        // reveal added padding to balance the notifs disappearing.
        scrollPanel.checkScroll();
      }
    });
    this.state = {
      // previous positions the read marker has been in, so we can
      // display 'ghost' read markers that are animating away
      ghostReadMarkers: [],
      showTypingNotifications: _SettingsStore.default.getValue("showTypingNotifications"),
      hideSender: this.shouldHideSender()
    };

    // Cache these settings on mount since Settings is expensive to query,
    // and we check this in a hot code path. This is also cached in our
    // RoomContext, however we still need a fallback for roomless MessagePanels.
    this._showHiddenEvents = _SettingsStore.default.getValue("showHiddenEventsInTimeline");
    this.showTypingNotificationsWatcherRef = _SettingsStore.default.watchSetting("showTypingNotifications", null, this.onShowTypingNotificationsChange);
  }
  componentDidMount() {
    this.calculateRoomMembersCount();
    this.props.room?.currentState.on(_matrix.RoomStateEvent.Update, this.calculateRoomMembersCount);
    this.isMounted = true;
  }
  componentWillUnmount() {
    this.isMounted = false;
    this.props.room?.currentState.off(_matrix.RoomStateEvent.Update, this.calculateRoomMembersCount);
    _SettingsStore.default.unwatchSetting(this.showTypingNotificationsWatcherRef);
    this.readReceiptMap = {};
  }
  componentDidUpdate(prevProps, prevState) {
    if (prevProps.layout !== this.props.layout) {
      this.calculateRoomMembersCount();
    }
    if (prevProps.readMarkerVisible && prevProps.readMarkerEventId && this.props.readMarkerEventId !== prevProps.readMarkerEventId) {
      const ghostReadMarkers = this.state.ghostReadMarkers;
      ghostReadMarkers.push(prevProps.readMarkerEventId);
      this.setState({
        ghostReadMarkers
      });
    }
    const pendingEditItem = this.pendingEditItem;
    if (!this.props.editState && this.props.room && pendingEditItem) {
      const event = this.props.room.findEventById(pendingEditItem);
      _dispatcher.default.dispatch({
        action: _actions.Action.EditEvent,
        event: !event?.isRedacted() ? event : null,
        timelineRenderingType: this.context.timelineRenderingType
      });
    }
  }
  shouldHideSender() {
    return !!this.props.room && this.props.room.getInvitedAndJoinedMemberCount() <= 2 && this.props.layout === _Layout.Layout.Bubble;
  }
  /* get the DOM node representing the given event */
  getNodeForEventId(eventId) {
    if (!this.eventTiles) {
      return undefined;
    }
    return this.eventTiles[eventId]?.ref?.current ?? undefined;
  }
  getTileForEventId(eventId) {
    if (!this.eventTiles || !eventId) {
      return undefined;
    }
    return this.eventTiles[eventId];
  }

  /* return true if the content is fully scrolled down right now; else false.
   */
  isAtBottom() {
    return this.scrollPanel.current?.isAtBottom();
  }

  /* get the current scroll state. See ScrollPanel.getScrollState for
   * details.
   *
   * returns null if we are not mounted.
   */
  getScrollState() {
    return this.scrollPanel.current?.getScrollState() ?? null;
  }

  // returns one of:
  //
  //  null: there is no read marker
  //  -1: read marker is above the window
  //   0: read marker is within the window
  //  +1: read marker is below the window
  getReadMarkerPosition() {
    const readMarker = this.readMarkerNode.current;
    const messageWrapper = this.scrollPanel.current;
    if (!readMarker || !messageWrapper) {
      return null;
    }
    const wrapperRect = _reactDom.default.findDOMNode(messageWrapper).getBoundingClientRect();
    const readMarkerRect = readMarker.getBoundingClientRect();

    // the read-marker pretends to have zero height when it is actually
    // two pixels high; +2 here to account for that.
    if (readMarkerRect.bottom + 2 < wrapperRect.top) {
      return -1;
    } else if (readMarkerRect.top < wrapperRect.bottom) {
      return 0;
    } else {
      return 1;
    }
  }

  /* jump to the top of the content.
   */
  scrollToTop() {
    this.scrollPanel.current?.scrollToTop();
  }

  /* jump to the bottom of the content.
   */
  scrollToBottom() {
    this.scrollPanel.current?.scrollToBottom();
  }

  /**
   * Scroll up/down in response to a scroll key
   *
   * @param {KeyboardEvent} ev: the keyboard event to handle
   */
  handleScrollKey(ev) {
    this.scrollPanel.current?.handleScrollKey(ev);
  }

  /* jump to the given event id.
   *
   * offsetBase gives the reference point for the pixelOffset. 0 means the
   * top of the container, 1 means the bottom, and fractional values mean
   * somewhere in the middle. If omitted, it defaults to 0.
   *
   * pixelOffset gives the number of pixels *above* the offsetBase that the
   * node (specifically, the bottom of it) will be positioned. If omitted, it
   * defaults to 0.
   */
  scrollToEvent(eventId, pixelOffset, offsetBase) {
    this.scrollPanel.current?.scrollToToken(eventId, pixelOffset, offsetBase);
  }
  scrollToEventIfNeeded(eventId) {
    const node = this.getNodeForEventId(eventId);
    if (node) {
      node.scrollIntoView({
        block: "nearest",
        behavior: "instant"
      });
    }
  }
  get showHiddenEvents() {
    return this.context?.showHiddenEvents ?? this._showHiddenEvents;
  }

  // TODO: Implement granular (per-room) hide options
  shouldShowEvent(mxEv, forceHideEvents = false) {
    if (this.props.hideThreadedMessages && this.props.room) {
      const {
        shouldLiveInRoom
      } = this.props.room.eventShouldLiveIn(mxEv, this.props.events);
      if (!shouldLiveInRoom) {
        return false;
      }
    }
    if (_MatrixClientPeg.MatrixClientPeg.safeGet().isUserIgnored(mxEv.getSender())) {
      return false; // ignored = no show (only happens if the ignore happens after an event was received)
    }
    if (this.showHiddenEvents && !forceHideEvents) {
      return true;
    }
    if (!(0, _EventTileFactory.haveRendererForEvent)(mxEv, _MatrixClientPeg.MatrixClientPeg.safeGet(), this.showHiddenEvents)) {
      return false; // no tile = no show
    }

    // Always show highlighted event
    if (this.props.highlightedEventId === mxEv.getId()) return true;
    return !(0, _shouldHideEvent.default)(mxEv, this.context);
  }
  readMarkerForEvent(eventId, isLastEvent) {
    if (this.context.timelineRenderingType === _RoomContext.TimelineRenderingType.File) return null;
    const visible = !isLastEvent && this.props.readMarkerVisible;
    if (this.props.readMarkerEventId === eventId) {
      let hr;
      // if the read marker comes at the end of the timeline (except
      // for local echoes, which are excluded from RMs, because they
      // don't have useful event ids), we don't want to show it, but
      // we still want to create the <li/> for it so that the
      // algorithms which depend on its position on the screen aren't
      // confused.
      if (visible) {
        hr = /*#__PURE__*/_react.default.createElement("hr", {
          style: {
            opacity: 1,
            width: "99%"
          }
        });
      }
      return /*#__PURE__*/_react.default.createElement("li", {
        key: "readMarker_" + eventId,
        ref: this.readMarkerNode,
        className: "mx_MessagePanel_myReadMarker",
        "data-scroll-tokens": eventId
      }, hr);
    } else if (this.state.ghostReadMarkers.includes(eventId)) {
      // We render 'ghost' read markers in the DOM while they
      // transition away. This allows the actual read marker
      // to be in the right place straight away without having
      // to wait for the transition to finish.
      // There are probably much simpler ways to do this transition,
      // possibly using react-transition-group which handles keeping
      // elements in the DOM whilst they transition out, although our
      // case is a little more complex because only some of the items
      // transition (ie. the read markers do but the event tiles do not)
      // and TransitionGroup requires that all its children are Transitions.
      const hr = /*#__PURE__*/_react.default.createElement("hr", {
        ref: this.collectGhostReadMarker,
        onTransitionEnd: this.onGhostTransitionEnd,
        "data-eventid": eventId
      });

      // give it a key which depends on the event id. That will ensure that
      // we get a new DOM node (restarting the animation) when the ghost
      // moves to a different event.
      return /*#__PURE__*/_react.default.createElement("li", {
        key: "_readuptoghost_" + eventId,
        className: "mx_MessagePanel_myReadMarker"
      }, hr);
    }
    return null;
  }
  /**
   * Find the next event in the list, and the next visible event in the list.
   *
   * @param events     - the list of events to look in and whether they are shown
   * @param i          - where in the list we are now
   *
   * @returns { nextEvent, nextTile }
   *
   * nextEvent is the event after i in the supplied array.
   *
   * nextTile is the first event in the array after i that we will show a tile
   * for. It is used to to determine the 'last successful' flag when rendering
   * the tile.
   */
  getNextEventInfo(events, i) {
    // WARNING: this method is on a hot path.

    const nextEventAndShouldShow = i < events.length - 1 ? events[i + 1] : null;
    const nextTile = findFirstShownAfter(i, events);
    return {
      nextEventAndShouldShow,
      nextTile
    };
  }
  get pendingEditItem() {
    if (!this.props.room) {
      return null;
    }
    try {
      return localStorage.getItem((0, _Editing.editorRoomKey)(this.props.room.roomId, this.context.timelineRenderingType));
    } catch (err) {
      _logger.logger.error(err);
      return null;
    }
  }
  isSentState(ev) {
    const status = ev.getAssociatedStatus();
    // A falsey state applies to events which have come down sync, including remote echoes
    return !status || status === _matrix.EventStatus.SENT;
  }
  getEventTiles() {
    // first figure out which is the last event in the list which we're
    // actually going to show; this allows us to behave slightly
    // differently for the last event in the list. (eg show timestamp)
    //
    // we also need to figure out which is the last event we show which isn't
    // a local echo, to manage the read-marker.
    let lastShownEvent;
    const events = this.props.events.map(event => {
      return {
        event,
        shouldShow: this.shouldShowEvent(event)
      };
    });
    const userId = _MatrixClientPeg.MatrixClientPeg.safeGet().getSafeUserId();
    let foundLastSuccessfulEvent = false;
    let lastShownNonLocalEchoIndex = -1;
    // Find the indices of the last successful event we sent and the last non-local-echo events shown
    for (let i = events.length - 1; i >= 0; i--) {
      const {
        event,
        shouldShow
      } = events[i];
      if (!shouldShow) {
        continue;
      }
      if (lastShownEvent === undefined) {
        lastShownEvent = event;
      }
      if (!foundLastSuccessfulEvent && this.isSentState(event) && (0, _EventTile.isEligibleForSpecialReceipt)(event)) {
        foundLastSuccessfulEvent = true;
        // If we are not sender of this last successful event eligible for special receipt then we stop here
        // As we do not want to render our sent receipt if there are more receipts below it and events sent
        // by other users get a synthetic read receipt for their sent events.
        if (event.getSender() === userId) {
          events[i].lastSuccessfulWeSent = true;
        }
      }
      if (lastShownNonLocalEchoIndex < 0 && !event.status) {
        lastShownNonLocalEchoIndex = i;
      }
      if (lastShownNonLocalEchoIndex >= 0 && foundLastSuccessfulEvent) {
        break;
      }
    }
    const ret = [];
    let prevEvent = null; // the last event we showed

    // Note: the EventTile might still render a "sent/sending receipt" independent of
    // this information. When not providing read receipt information, the tile is likely
    // to assume that sent receipts are to be shown more often.
    this.readReceiptsByEvent = new Map();
    if (this.props.showReadReceipts) {
      this.readReceiptsByEvent = this.getReadReceiptsByShownEvent(events);
    }
    let grouper = null;
    for (let i = 0; i < events.length; i++) {
      const wrappedEvent = events[i];
      const {
        event,
        shouldShow
      } = wrappedEvent;
      const eventId = event.getId();
      const last = event === lastShownEvent;
      const {
        nextEventAndShouldShow,
        nextTile
      } = this.getNextEventInfo(events, i);
      if (grouper) {
        if (grouper.shouldGroup(wrappedEvent)) {
          grouper.add(wrappedEvent);
          continue;
        } else {
          // not part of group, so get the group tiles, close the
          // group, and continue like a normal event
          ret.push(...grouper.getTiles());
          prevEvent = grouper.getNewPrevEvent();
          grouper = null;
        }
      }
      for (const Grouper of groupers) {
        if (Grouper.canStartGroup(this, wrappedEvent) && !this.props.disableGrouping) {
          grouper = new Grouper(this, wrappedEvent, prevEvent, lastShownEvent, nextEventAndShouldShow, nextTile);
          break; // break on first grouper
        }
      }
      if (!grouper) {
        if (shouldShow) {
          // make sure we unpack the array returned by getTilesForEvent,
          // otherwise React will auto-generate keys, and we will end up
          // replacing all the DOM elements every time we paginate.
          ret.push(...this.getTilesForEvent(prevEvent, wrappedEvent, last, false, nextEventAndShouldShow, nextTile));
          prevEvent = event;
        }
        const readMarker = this.readMarkerForEvent(eventId, i >= lastShownNonLocalEchoIndex);
        if (readMarker) ret.push(readMarker);
      }
    }
    if (grouper) {
      ret.push(...grouper.getTiles());
    }
    return ret;
  }
  getTilesForEvent(prevEvent, wrappedEvent, last = false, isGrouped = false, nextEvent = null, nextEventWithTile = null) {
    const mxEv = wrappedEvent.event;
    const ret = [];
    const isEditing = this.props.editState?.getEvent().getId() === mxEv.getId();
    // local echoes have a fake date, which could even be yesterday. Treat them as 'today' for the date separators.
    const ts1 = mxEv.getTs() ?? Date.now();

    // do we need a separator since the last event?
    const wantsSeparator = this.wantsSeparator(prevEvent, mxEv);
    if (!isGrouped && this.props.room) {
      if (wantsSeparator === _TimelineSeparator.SeparatorKind.Date) {
        ret.push( /*#__PURE__*/_react.default.createElement("li", {
          key: ts1
        }, /*#__PURE__*/_react.default.createElement(_DateSeparator.default, {
          key: ts1,
          roomId: this.props.room.roomId,
          ts: ts1
        })));
      } else if (wantsSeparator === _TimelineSeparator.SeparatorKind.LateEvent) {
        const text = (0, _languageHandler._t)("timeline|late_event_separator", {
          dateTime: (0, _DateUtils.formatDate)(mxEv.getDate() ?? new Date())
        });
        ret.push( /*#__PURE__*/_react.default.createElement("li", {
          key: ts1
        }, /*#__PURE__*/_react.default.createElement(_TimelineSeparator.default, {
          key: ts1,
          label: text
        }, text)));
      }
    }
    const cli = _MatrixClientPeg.MatrixClientPeg.safeGet();
    let lastInSection = true;
    if (nextEventWithTile) {
      const nextEv = nextEventWithTile;
      const willWantSeparator = this.wantsSeparator(mxEv, nextEv);
      lastInSection = willWantSeparator === _TimelineSeparator.SeparatorKind.Date || mxEv.getSender() !== nextEv.getSender() || (0, _EventRenderingUtils.getEventDisplayInfo)(cli, nextEv, this.showHiddenEvents).isInfoMessage || !shouldFormContinuation(mxEv, nextEv, cli, this.showHiddenEvents, this.context.timelineRenderingType);
    }

    // is this a continuation of the previous message?
    const continuation = wantsSeparator === _TimelineSeparator.SeparatorKind.None && shouldFormContinuation(prevEvent, mxEv, cli, this.showHiddenEvents, this.context.timelineRenderingType);
    const eventId = mxEv.getId();
    const highlight = eventId === this.props.highlightedEventId;
    const readReceipts = this.readReceiptsByEvent.get(eventId);
    const callEventGrouper = this.props.callEventGroupers.get(mxEv.getContent().call_id);
    // use txnId as key if available so that we don't remount during sending
    ret.push( /*#__PURE__*/_react.default.createElement(_EventTile.default, {
      key: mxEv.getTxnId() || eventId,
      as: "li",
      ref: this.collectEventTile.bind(this, eventId),
      alwaysShowTimestamps: this.props.alwaysShowTimestamps,
      mxEvent: mxEv,
      continuation: continuation,
      isRedacted: mxEv.isRedacted(),
      replacingEventId: mxEv.replacingEventId(),
      editState: isEditing ? this.props.editState : undefined,
      onHeightChanged: this.onHeightChanged,
      readReceipts: readReceipts,
      readReceiptMap: this.readReceiptMap,
      showUrlPreview: this.props.showUrlPreview,
      checkUnmounting: this.isUnmounting,
      eventSendStatus: mxEv.getAssociatedStatus() ?? undefined,
      isTwelveHour: this.props.isTwelveHour,
      permalinkCreator: this.props.permalinkCreator,
      last: last,
      lastInSection: lastInSection,
      lastSuccessful: wrappedEvent.lastSuccessfulWeSent,
      isSelectedEvent: highlight,
      getRelationsForEvent: this.props.getRelationsForEvent,
      showReactions: this.props.showReactions,
      layout: this.props.layout,
      showReadReceipts: this.props.showReadReceipts,
      callEventGrouper: callEventGrouper,
      hideSender: this.state.hideSender
    }));
    return ret;
  }
  wantsSeparator(prevEvent, mxEvent) {
    if (this.context.timelineRenderingType === _RoomContext.TimelineRenderingType.ThreadsList) {
      return _TimelineSeparator.SeparatorKind.None;
    }
    if (prevEvent !== null) {
      // If the previous event was late but current is not then show a date separator for orientation
      // Otherwise if the current event is of a different late group than the previous show a late event separator
      const lateEventInfo = (0, _LateEventGrouper.getLateEventInfo)(mxEvent);
      if (lateEventInfo?.group_id !== (0, _LateEventGrouper.getLateEventInfo)(prevEvent)?.group_id) {
        return lateEventInfo !== undefined ? _TimelineSeparator.SeparatorKind.LateEvent : _TimelineSeparator.SeparatorKind.Date;
      }
    }

    // first event in the panel: depends on if we could back-paginate from here.
    if (prevEvent === null && !this.props.canBackPaginate) {
      return _TimelineSeparator.SeparatorKind.Date;
    }
    const nextEventDate = mxEvent.getDate() ?? new Date();
    if (prevEvent !== null && (0, _DateUtils.wantsDateSeparator)(prevEvent.getDate() || undefined, nextEventDate)) {
      return _TimelineSeparator.SeparatorKind.Date;
    }
    return _TimelineSeparator.SeparatorKind.None;
  }

  // Get a list of read receipts that should be shown next to this event
  // Receipts are objects which have a 'userId', 'roomMember' and 'ts'.
  getReadReceiptsForEvent(event) {
    const myUserId = _MatrixClientPeg.MatrixClientPeg.safeGet().credentials.userId;

    // get list of read receipts, sorted most recent first
    const {
      room
    } = this.props;
    if (!room) {
      return null;
    }
    const receiptDestination = this.context.threadId ? room.getThread(this.context.threadId) : room;
    const receipts = [];
    if (!receiptDestination) {
      _logger.logger.debug("Discarding request, could not find the receiptDestination for event: " + this.context.threadId);
      return receipts;
    }
    receiptDestination.getReceiptsForEvent(event).forEach(r => {
      if (!r.userId || !(0, _utils.isSupportedReceiptType)(r.type) || r.userId === myUserId) {
        return; // ignore non-read receipts and receipts from self.
      }
      if (_MatrixClientPeg.MatrixClientPeg.safeGet().isUserIgnored(r.userId)) {
        return; // ignore ignored users
      }
      const member = room.getMember(r.userId);
      receipts.push({
        userId: r.userId,
        roomMember: member,
        ts: r.data ? r.data.ts : 0
      });
    });
    return receipts;
  }

  // Get an object that maps from event ID to a list of read receipts that
  // should be shown next to that event. If a hidden event has read receipts,
  // they are folded into the receipts of the last shown event.
  getReadReceiptsByShownEvent(events) {
    const receiptsByEvent = new Map();
    const receiptsByUserId = new Map();
    let lastShownEventId;
    for (const event of this.props.events) {
      if (this.shouldShowEvent(event)) {
        lastShownEventId = event.getId();
      }
      if (!lastShownEventId) {
        continue;
      }
      const existingReceipts = receiptsByEvent.get(lastShownEventId) || [];
      const newReceipts = this.getReadReceiptsForEvent(event);
      if (!newReceipts) continue;
      receiptsByEvent.set(lastShownEventId, existingReceipts.concat(newReceipts));

      // Record these receipts along with their last shown event ID for
      // each associated user ID.
      for (const receipt of newReceipts) {
        receiptsByUserId.set(receipt.userId, {
          lastShownEventId,
          receipt
        });
      }
    }

    // It's possible in some cases (for example, when a read receipt
    // advances before we have paginated in the new event that it's marking
    // received) that we can temporarily not have a matching event for
    // someone which had one in the last. By looking through our previous
    // mapping of receipts by user ID, we can cover recover any receipts
    // that would have been lost by using the same event ID from last time.
    for (const userId of this.readReceiptsByUserId.keys()) {
      if (receiptsByUserId.get(userId)) {
        continue;
      }
      const {
        lastShownEventId,
        receipt
      } = this.readReceiptsByUserId.get(userId);
      const existingReceipts = receiptsByEvent.get(lastShownEventId) || [];
      receiptsByEvent.set(lastShownEventId, existingReceipts.concat(receipt));
      receiptsByUserId.set(userId, {
        lastShownEventId,
        receipt
      });
    }
    this.readReceiptsByUserId = receiptsByUserId;

    // After grouping receipts by shown events, do another pass to sort each
    // receipt list.
    for (const receipts of receiptsByEvent.values()) {
      receipts.sort((r1, r2) => {
        return r2.ts - r1.ts;
      });
    }
    return receiptsByEvent;
  }
  updateTimelineMinHeight() {
    const scrollPanel = this.scrollPanel.current;
    if (scrollPanel) {
      const isAtBottom = scrollPanel.isAtBottom();
      const whoIsTyping = this.whoIsTyping.current;
      const isTypingVisible = whoIsTyping && whoIsTyping.isVisible();
      // when messages get added to the timeline,
      // but somebody else is still typing,
      // update the min-height, so once the last
      // person stops typing, no jumping occurs
      if (isAtBottom && isTypingVisible) {
        scrollPanel.preventShrinking();
      }
    }
  }
  onTimelineReset() {
    const scrollPanel = this.scrollPanel.current;
    if (scrollPanel) {
      scrollPanel.clearPreventShrinking();
    }
  }
  render() {
    let topSpinner;
    let bottomSpinner;
    if (this.props.backPaginating) {
      topSpinner = /*#__PURE__*/_react.default.createElement("li", {
        key: "_topSpinner"
      }, /*#__PURE__*/_react.default.createElement(_Spinner.default, null));
    }
    if (this.props.forwardPaginating) {
      bottomSpinner = /*#__PURE__*/_react.default.createElement("li", {
        key: "_bottomSpinner"
      }, /*#__PURE__*/_react.default.createElement(_Spinner.default, null));
    }
    const style = this.props.hidden ? {
      display: "none"
    } : {};
    let whoIsTyping;
    if (this.props.room && this.state.showTypingNotifications && this.context.timelineRenderingType === _RoomContext.TimelineRenderingType.Room) {
      whoIsTyping = /*#__PURE__*/_react.default.createElement(_WhoIsTypingTile.default, {
        room: this.props.room,
        onShown: this.onTypingShown,
        onHidden: this.onTypingHidden,
        ref: this.whoIsTyping
      });
    }
    let ircResizer;
    if (this.props.layout == _Layout.Layout.IRC) {
      ircResizer = /*#__PURE__*/_react.default.createElement(_IRCTimelineProfileResizer.default, {
        minWidth: 20,
        maxWidth: 600,
        roomId: this.props.room?.roomId ?? null
      });
    }
    const classes = (0, _classnames.default)(this.props.className, {
      mx_MessagePanel_narrow: this.context.narrow
    });
    return /*#__PURE__*/_react.default.createElement(_ErrorBoundary.default, null, /*#__PURE__*/_react.default.createElement(_ScrollPanel.default, {
      ref: this.scrollPanel,
      className: classes,
      onScroll: this.props.onScroll,
      onFillRequest: this.props.onFillRequest,
      onUnfillRequest: this.props.onUnfillRequest,
      style: style,
      stickyBottom: this.props.stickyBottom,
      resizeNotifier: this.props.resizeNotifier,
      fixedChildren: ircResizer
    }, topSpinner, this.getEventTiles(), whoIsTyping, bottomSpinner));
  }
}

/**
 * Holds on to an event, caching the information about it in the context of the current messages list.
 * Avoids calling shouldShowEvent more times than we need to.
 * Simplifies threading of event context like whether it's the last successful event we sent which cannot be determined
 * by a consumer from the event alone, so has to be done by the event list processing code earlier.
 */
exports.default = MessagePanel;
(0, _defineProperty2.default)(MessagePanel, "contextType", _RoomContext.default);
(0, _defineProperty2.default)(MessagePanel, "defaultProps", {
  disableGrouping: false
});
// all the grouper classes that we use, ordered by priority
const groupers = [_CreationGrouper.CreationGrouper, _MainGrouper.MainGrouper];

/**
 * Look through the supplied list of WrappedEvent, and return the first
 * event that is >start items through the list, and is shown.
 */
function findFirstShownAfter(start, events) {
  // Note: this could be done with something like:
  // events.slice(i + 1).find((e) => e.shouldShow)?.event ?? null;
  // but it is ~10% slower, and this is on the critical path.

  for (let n = start + 1; n < events.length; n++) {
    const {
      event,
      shouldShow
    } = events[n];
    if (shouldShow) {
      return event;
    }
  }
  return null;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_reactDom","_interopRequireDefault","_classnames","_matrix","_logger","_utils","_shouldHideEvent","_DateUtils","_MatrixClientPeg","_SettingsStore","_RoomContext","_Layout","_EventTile","_IRCTimelineProfileResizer","_dispatcher","_WhoIsTypingTile","_ScrollPanel","_DateSeparator","_TimelineSeparator","_ErrorBoundary","_Spinner","_actions","_EventRenderingUtils","_EventTileFactory","_Editing","_EventUtils","_MainGrouper","_CreationGrouper","_languageHandler","_LateEventGrouper","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","CONTINUATION_MAX_INTERVAL","continuedTypes","EventType","Sticker","RoomMessage","shouldFormContinuation","prevEvent","mxEvent","matrixClient","showHiddenEvents","timelineRenderingType","TimelineRenderingType","ThreadsList","sender","getTs","isRedacted","getType","includes","userId","name","getMxcAvatarUrl","hasThreadSummary","Thread","haveRendererForEvent","MessagePanel","React","Component","constructor","props","context","_defineProperty2","Map","createRef","setState","hideSender","shouldHideSender","showTypingNotifications","SettingsStore","getValue","isMounted","node","requestAnimationFrame","style","width","opacity","ev","finishedEventId","target","dataset","eventid","ghostReadMarkers","state","filter","eid","eventId","eventTiles","scrollPanel","current","checkScroll","getScrollState","stuckAtBottom","preventShrinking","updatePreventShrinking","_showHiddenEvents","showTypingNotificationsWatcherRef","watchSetting","onShowTypingNotificationsChange","componentDidMount","calculateRoomMembersCount","room","currentState","on","RoomStateEvent","Update","componentWillUnmount","off","unwatchSetting","readReceiptMap","componentDidUpdate","prevProps","prevState","layout","readMarkerVisible","readMarkerEventId","push","pendingEditItem","editState","event","findEventById","defaultDispatcher","dispatch","action","Action","EditEvent","getInvitedAndJoinedMemberCount","Layout","Bubble","getNodeForEventId","undefined","ref","getTileForEventId","isAtBottom","getReadMarkerPosition","readMarker","readMarkerNode","messageWrapper","wrapperRect","ReactDOM","findDOMNode","getBoundingClientRect","readMarkerRect","bottom","top","scrollToTop","scrollToBottom","handleScrollKey","scrollToEvent","pixelOffset","offsetBase","scrollToToken","scrollToEventIfNeeded","scrollIntoView","block","behavior","shouldShowEvent","mxEv","forceHideEvents","hideThreadedMessages","shouldLiveInRoom","eventShouldLiveIn","events","MatrixClientPeg","safeGet","isUserIgnored","getSender","highlightedEventId","getId","shouldHideEvent","readMarkerForEvent","isLastEvent","File","visible","hr","createElement","key","className","collectGhostReadMarker","onTransitionEnd","onGhostTransitionEnd","getNextEventInfo","nextEventAndShouldShow","length","nextTile","findFirstShownAfter","localStorage","getItem","editorRoomKey","roomId","err","logger","error","isSentState","status","getAssociatedStatus","EventStatus","SENT","getEventTiles","lastShownEvent","map","shouldShow","getSafeUserId","foundLastSuccessfulEvent","lastShownNonLocalEchoIndex","isEligibleForSpecialReceipt","lastSuccessfulWeSent","ret","readReceiptsByEvent","showReadReceipts","getReadReceiptsByShownEvent","grouper","wrappedEvent","last","shouldGroup","add","getTiles","getNewPrevEvent","Grouper","groupers","canStartGroup","disableGrouping","getTilesForEvent","isGrouped","nextEvent","nextEventWithTile","isEditing","getEvent","ts1","Date","now","wantsSeparator","SeparatorKind","ts","LateEvent","text","_t","dateTime","formatDate","getDate","label","cli","lastInSection","nextEv","willWantSeparator","getEventDisplayInfo","isInfoMessage","continuation","None","highlight","readReceipts","callEventGrouper","callEventGroupers","getContent","call_id","getTxnId","as","collectEventTile","bind","alwaysShowTimestamps","replacingEventId","onHeightChanged","showUrlPreview","checkUnmounting","isUnmounting","eventSendStatus","isTwelveHour","permalinkCreator","lastSuccessful","isSelectedEvent","getRelationsForEvent","showReactions","lateEventInfo","getLateEventInfo","group_id","canBackPaginate","nextEventDate","wantsDateSeparator","getReadReceiptsForEvent","myUserId","credentials","receiptDestination","threadId","getThread","receipts","debug","getReceiptsForEvent","forEach","isSupportedReceiptType","type","member","getMember","roomMember","data","receiptsByEvent","receiptsByUserId","lastShownEventId","existingReceipts","newReceipts","concat","receipt","readReceiptsByUserId","keys","values","sort","r1","r2","updateTimelineMinHeight","whoIsTyping","isTypingVisible","isVisible","onTimelineReset","clearPreventShrinking","render","topSpinner","bottomSpinner","backPaginating","forwardPaginating","hidden","display","Room","onShown","onTypingShown","onHidden","onTypingHidden","ircResizer","IRC","minWidth","maxWidth","classes","classNames","mx_MessagePanel_narrow","narrow","onScroll","onFillRequest","onUnfillRequest","stickyBottom","resizeNotifier","fixedChildren","exports","RoomContext","CreationGrouper","MainGrouper","start"],"sources":["../../../src/components/structures/MessagePanel.tsx"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2016-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, { createRef, ReactNode, TransitionEvent } from \"react\";\nimport ReactDOM from \"react-dom\";\nimport classNames from \"classnames\";\nimport { Room, MatrixClient, RoomStateEvent, EventStatus, MatrixEvent, EventType } from \"matrix-js-sdk/src/matrix\";\nimport { logger } from \"matrix-js-sdk/src/logger\";\nimport { isSupportedReceiptType } from \"matrix-js-sdk/src/utils\";\n\nimport shouldHideEvent from \"../../shouldHideEvent\";\nimport { formatDate, wantsDateSeparator } from \"../../DateUtils\";\nimport { MatrixClientPeg } from \"../../MatrixClientPeg\";\nimport SettingsStore from \"../../settings/SettingsStore\";\nimport RoomContext, { TimelineRenderingType } from \"../../contexts/RoomContext\";\nimport { Layout } from \"../../settings/enums/Layout\";\nimport EventTile, {\n    GetRelationsForEvent,\n    IReadReceiptProps,\n    isEligibleForSpecialReceipt,\n    UnwrappedEventTile,\n} from \"../views/rooms/EventTile\";\nimport IRCTimelineProfileResizer from \"../views/elements/IRCTimelineProfileResizer\";\nimport defaultDispatcher from \"../../dispatcher/dispatcher\";\nimport LegacyCallEventGrouper from \"./LegacyCallEventGrouper\";\nimport WhoIsTypingTile from \"../views/rooms/WhoIsTypingTile\";\nimport ScrollPanel, { IScrollState } from \"./ScrollPanel\";\nimport DateSeparator from \"../views/messages/DateSeparator\";\nimport TimelineSeparator, { SeparatorKind } from \"../views/messages/TimelineSeparator\";\nimport ErrorBoundary from \"../views/elements/ErrorBoundary\";\nimport ResizeNotifier from \"../../utils/ResizeNotifier\";\nimport Spinner from \"../views/elements/Spinner\";\nimport { RoomPermalinkCreator } from \"../../utils/permalinks/Permalinks\";\nimport EditorStateTransfer from \"../../utils/EditorStateTransfer\";\nimport { Action } from \"../../dispatcher/actions\";\nimport { getEventDisplayInfo } from \"../../utils/EventRenderingUtils\";\nimport { IReadReceiptPosition } from \"../views/rooms/ReadReceiptMarker\";\nimport { haveRendererForEvent } from \"../../events/EventTileFactory\";\nimport { editorRoomKey } from \"../../Editing\";\nimport { hasThreadSummary } from \"../../utils/EventUtils\";\nimport { BaseGrouper } from \"./grouper/BaseGrouper\";\nimport { MainGrouper } from \"./grouper/MainGrouper\";\nimport { CreationGrouper } from \"./grouper/CreationGrouper\";\nimport { _t } from \"../../languageHandler\";\nimport { getLateEventInfo } from \"./grouper/LateEventGrouper\";\n\nconst CONTINUATION_MAX_INTERVAL = 5 * 60 * 1000; // 5 minutes\nconst continuedTypes = [EventType.Sticker, EventType.RoomMessage];\n\n// check if there is a previous event and it has the same sender as this event\n// and the types are the same/is in continuedTypes and the time between them is <= CONTINUATION_MAX_INTERVAL\nexport function shouldFormContinuation(\n    prevEvent: MatrixEvent | null,\n    mxEvent: MatrixEvent,\n    matrixClient: MatrixClient,\n    showHiddenEvents: boolean,\n    timelineRenderingType?: TimelineRenderingType,\n): boolean {\n    if (timelineRenderingType === TimelineRenderingType.ThreadsList) return false;\n    // sanity check inputs\n    if (!prevEvent?.sender || !mxEvent.sender) return false;\n    // check if within the max continuation period\n    if (mxEvent.getTs() - prevEvent.getTs() > CONTINUATION_MAX_INTERVAL) return false;\n\n    // As we summarise redactions, do not continue a redacted event onto a non-redacted one and vice-versa\n    if (mxEvent.isRedacted() !== prevEvent.isRedacted()) return false;\n\n    // Some events should appear as continuations from previous events of different types.\n    if (\n        mxEvent.getType() !== prevEvent.getType() &&\n        (!continuedTypes.includes(mxEvent.getType() as EventType) ||\n            !continuedTypes.includes(prevEvent.getType() as EventType))\n    )\n        return false;\n\n    // Check if the sender is the same and hasn't changed their displayname/avatar between these events\n    if (\n        mxEvent.sender.userId !== prevEvent.sender.userId ||\n        mxEvent.sender.name !== prevEvent.sender.name ||\n        mxEvent.sender.getMxcAvatarUrl() !== prevEvent.sender.getMxcAvatarUrl()\n    )\n        return false;\n\n    // Thread summaries in the main timeline should break up a cont