339 lines
13 KiB
JavaScript
339 lines
13 KiB
JavaScript
"use strict";
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.RelationsEvent = exports.Relations = void 0;
|
|
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
|
|
var _event = require("./event");
|
|
var _logger = require("../logger");
|
|
var _event2 = require("../@types/event");
|
|
var _typedEventEmitter = require("./typed-event-emitter");
|
|
var _room = require("./room");
|
|
/*
|
|
Copyright 2019, 2021, 2023 The Matrix.org Foundation C.I.C.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
let RelationsEvent = /*#__PURE__*/function (RelationsEvent) {
|
|
RelationsEvent["Add"] = "Relations.add";
|
|
RelationsEvent["Remove"] = "Relations.remove";
|
|
RelationsEvent["Redaction"] = "Relations.redaction";
|
|
return RelationsEvent;
|
|
}({});
|
|
exports.RelationsEvent = RelationsEvent;
|
|
const matchesEventType = (eventType, targetEventType, altTargetEventTypes = []) => [targetEventType, ...altTargetEventTypes].includes(eventType);
|
|
|
|
/**
|
|
* A container for relation events that supports easy access to common ways of
|
|
* aggregating such events. Each instance holds events that of a single relation
|
|
* type and event type. All of the events also relate to the same original event.
|
|
*
|
|
* The typical way to get one of these containers is via
|
|
* EventTimelineSet#getRelationsForEvent.
|
|
*/
|
|
class Relations extends _typedEventEmitter.TypedEventEmitter {
|
|
/**
|
|
* @param relationType - The type of relation involved, such as "m.annotation", "m.reference", "m.replace", etc.
|
|
* @param eventType - The relation event's type, such as "m.reaction", etc.
|
|
* @param client - The client which created this instance. For backwards compatibility also accepts a Room.
|
|
* @param altEventTypes - alt event types for relation events, for example to support unstable prefixed event types
|
|
*/
|
|
constructor(relationType, eventType, client, altEventTypes) {
|
|
super();
|
|
this.relationType = relationType;
|
|
this.eventType = eventType;
|
|
this.altEventTypes = altEventTypes;
|
|
(0, _defineProperty2.default)(this, "relationEventIds", new Set());
|
|
(0, _defineProperty2.default)(this, "relations", new Set());
|
|
(0, _defineProperty2.default)(this, "annotationsByKey", {});
|
|
(0, _defineProperty2.default)(this, "annotationsBySender", {});
|
|
(0, _defineProperty2.default)(this, "sortedAnnotationsByKey", []);
|
|
(0, _defineProperty2.default)(this, "targetEvent", null);
|
|
(0, _defineProperty2.default)(this, "creationEmitted", false);
|
|
(0, _defineProperty2.default)(this, "client", void 0);
|
|
/**
|
|
* Listens for event status changes to remove cancelled events.
|
|
*
|
|
* @param event - The event whose status has changed
|
|
* @param status - The new status
|
|
*/
|
|
(0, _defineProperty2.default)(this, "onEventStatus", (event, status) => {
|
|
if (!event.isSending()) {
|
|
// Sending is done, so we don't need to listen anymore
|
|
event.removeListener(_event.MatrixEventEvent.Status, this.onEventStatus);
|
|
return;
|
|
}
|
|
if (status !== _event.EventStatus.CANCELLED) {
|
|
return;
|
|
}
|
|
// Event was cancelled, remove from the collection
|
|
event.removeListener(_event.MatrixEventEvent.Status, this.onEventStatus);
|
|
this.removeEvent(event);
|
|
});
|
|
/**
|
|
* For relations that have been redacted, we want to remove them from
|
|
* aggregation data sets and emit an update event.
|
|
*
|
|
* To do so, we listen for `Event.beforeRedaction`, which happens:
|
|
* - after the server accepted the redaction and remote echoed back to us
|
|
* - before the original event has been marked redacted in the client
|
|
*
|
|
* @param redactedEvent - The original relation event that is about to be redacted.
|
|
*/
|
|
(0, _defineProperty2.default)(this, "onBeforeRedaction", async redactedEvent => {
|
|
if (!this.relations.has(redactedEvent)) {
|
|
return;
|
|
}
|
|
this.relations.delete(redactedEvent);
|
|
if (this.relationType === _event2.RelationType.Annotation) {
|
|
// Remove the redacted annotation from aggregation by key
|
|
this.removeAnnotationFromAggregation(redactedEvent);
|
|
} else if (this.relationType === _event2.RelationType.Replace && this.targetEvent && !this.targetEvent.isState()) {
|
|
const lastReplacement = await this.getLastReplacement();
|
|
this.targetEvent.makeReplaced(lastReplacement);
|
|
}
|
|
redactedEvent.removeListener(_event.MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
|
|
this.emit(RelationsEvent.Redaction, redactedEvent);
|
|
});
|
|
this.client = client instanceof _room.Room ? client.client : client;
|
|
}
|
|
|
|
/**
|
|
* Add relation events to this collection.
|
|
*
|
|
* @param event - The new relation event to be added.
|
|
*/
|
|
async addEvent(event) {
|
|
if (this.relationEventIds.has(event.getId())) {
|
|
return;
|
|
}
|
|
const relation = event.getRelation();
|
|
if (!relation) {
|
|
_logger.logger.error("Event must have relation info");
|
|
return;
|
|
}
|
|
const relationType = relation.rel_type;
|
|
const eventType = event.getType();
|
|
if (this.relationType !== relationType || !matchesEventType(eventType, this.eventType, this.altEventTypes)) {
|
|
_logger.logger.error("Event relation info doesn't match this container");
|
|
return;
|
|
}
|
|
|
|
// If the event is in the process of being sent, listen for cancellation
|
|
// so we can remove the event from the collection.
|
|
if (event.isSending()) {
|
|
event.on(_event.MatrixEventEvent.Status, this.onEventStatus);
|
|
}
|
|
this.relations.add(event);
|
|
this.relationEventIds.add(event.getId());
|
|
if (this.relationType === _event2.RelationType.Annotation) {
|
|
this.addAnnotationToAggregation(event);
|
|
} else if (this.relationType === _event2.RelationType.Replace && this.targetEvent && !this.targetEvent.isState()) {
|
|
const lastReplacement = await this.getLastReplacement();
|
|
this.targetEvent.makeReplaced(lastReplacement);
|
|
}
|
|
event.on(_event.MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
|
|
this.emit(RelationsEvent.Add, event);
|
|
this.maybeEmitCreated();
|
|
}
|
|
|
|
/**
|
|
* Remove relation event from this collection.
|
|
*
|
|
* @param event - The relation event to remove.
|
|
*/
|
|
async removeEvent(event) {
|
|
if (!this.relations.has(event)) {
|
|
return;
|
|
}
|
|
this.relations.delete(event);
|
|
if (this.relationType === _event2.RelationType.Annotation) {
|
|
this.removeAnnotationFromAggregation(event);
|
|
} else if (this.relationType === _event2.RelationType.Replace && this.targetEvent && !this.targetEvent.isState()) {
|
|
const lastReplacement = await this.getLastReplacement();
|
|
this.targetEvent.makeReplaced(lastReplacement);
|
|
}
|
|
this.emit(RelationsEvent.Remove, event);
|
|
}
|
|
/**
|
|
* Get all relation events in this collection.
|
|
*
|
|
* These are currently in the order of insertion to this collection, which
|
|
* won't match timeline order in the case of scrollback.
|
|
* TODO: Tweak `addEvent` to insert correctly for scrollback.
|
|
*
|
|
* Relation events in insertion order.
|
|
*/
|
|
getRelations() {
|
|
return [...this.relations];
|
|
}
|
|
addAnnotationToAggregation(event) {
|
|
var _event$getRelation;
|
|
const {
|
|
key
|
|
} = (_event$getRelation = event.getRelation()) !== null && _event$getRelation !== void 0 ? _event$getRelation : {};
|
|
if (!key) return;
|
|
let eventsForKey = this.annotationsByKey[key];
|
|
if (!eventsForKey) {
|
|
eventsForKey = this.annotationsByKey[key] = new Set();
|
|
this.sortedAnnotationsByKey.push([key, eventsForKey]);
|
|
}
|
|
// Add the new event to the set for this key
|
|
eventsForKey.add(event);
|
|
// Re-sort the [key, events] pairs in descending order of event count
|
|
this.sortedAnnotationsByKey.sort((a, b) => {
|
|
const aEvents = a[1];
|
|
const bEvents = b[1];
|
|
return bEvents.size - aEvents.size;
|
|
});
|
|
const sender = event.getSender();
|
|
let eventsFromSender = this.annotationsBySender[sender];
|
|
if (!eventsFromSender) {
|
|
eventsFromSender = this.annotationsBySender[sender] = new Set();
|
|
}
|
|
// Add the new event to the set for this sender
|
|
eventsFromSender.add(event);
|
|
}
|
|
removeAnnotationFromAggregation(event) {
|
|
var _event$getRelation2;
|
|
const {
|
|
key
|
|
} = (_event$getRelation2 = event.getRelation()) !== null && _event$getRelation2 !== void 0 ? _event$getRelation2 : {};
|
|
if (!key) return;
|
|
const eventsForKey = this.annotationsByKey[key];
|
|
if (eventsForKey) {
|
|
eventsForKey.delete(event);
|
|
|
|
// Re-sort the [key, events] pairs in descending order of event count
|
|
this.sortedAnnotationsByKey.sort((a, b) => {
|
|
const aEvents = a[1];
|
|
const bEvents = b[1];
|
|
return bEvents.size - aEvents.size;
|
|
});
|
|
}
|
|
const sender = event.getSender();
|
|
const eventsFromSender = this.annotationsBySender[sender];
|
|
if (eventsFromSender) {
|
|
eventsFromSender.delete(event);
|
|
}
|
|
}
|
|
/**
|
|
* Get all events in this collection grouped by key and sorted by descending
|
|
* event count in each group.
|
|
*
|
|
* This is currently only supported for the annotation relation type.
|
|
*
|
|
* An array of [key, events] pairs sorted by descending event count.
|
|
* The events are stored in a Set (which preserves insertion order).
|
|
*/
|
|
getSortedAnnotationsByKey() {
|
|
if (this.relationType !== _event2.RelationType.Annotation) {
|
|
// Other relation types are not grouped currently.
|
|
return null;
|
|
}
|
|
return this.sortedAnnotationsByKey;
|
|
}
|
|
|
|
/**
|
|
* Get all events in this collection grouped by sender.
|
|
*
|
|
* This is currently only supported for the annotation relation type.
|
|
*
|
|
* An object with each relation sender as a key and the matching Set of
|
|
* events for that sender as a value.
|
|
*/
|
|
getAnnotationsBySender() {
|
|
if (this.relationType !== _event2.RelationType.Annotation) {
|
|
// Other relation types are not grouped currently.
|
|
return null;
|
|
}
|
|
return this.annotationsBySender;
|
|
}
|
|
|
|
/**
|
|
* Returns the most recent (and allowed) m.replace relation, if any.
|
|
*
|
|
* This is currently only supported for the m.replace relation type,
|
|
* once the target event is known, see `addEvent`.
|
|
*/
|
|
async getLastReplacement() {
|
|
if (this.relationType !== _event2.RelationType.Replace) {
|
|
// Aggregating on last only makes sense for this relation type
|
|
return null;
|
|
}
|
|
if (!this.targetEvent) {
|
|
// Don't know which replacements to accept yet.
|
|
// This method shouldn't be called before the original
|
|
// event is known anyway.
|
|
return null;
|
|
}
|
|
|
|
// the all-knowning server tells us that the event at some point had
|
|
// this timestamp for its replacement, so any following replacement should definitely not be less
|
|
const replaceRelation = this.targetEvent.getServerAggregatedRelation(_event2.RelationType.Replace);
|
|
const minTs = replaceRelation === null || replaceRelation === void 0 ? void 0 : replaceRelation.origin_server_ts;
|
|
const lastReplacement = this.getRelations().reduce((last, event) => {
|
|
if (event.getSender() !== this.targetEvent.getSender()) {
|
|
return last;
|
|
}
|
|
if (minTs && minTs > event.getTs()) {
|
|
return last;
|
|
}
|
|
if (last && last.getTs() > event.getTs()) {
|
|
return last;
|
|
}
|
|
return event;
|
|
}, null);
|
|
if (lastReplacement !== null && lastReplacement !== void 0 && lastReplacement.shouldAttemptDecryption() && this.client.isCryptoEnabled()) {
|
|
await lastReplacement.attemptDecryption(this.client.crypto);
|
|
} else if (lastReplacement !== null && lastReplacement !== void 0 && lastReplacement.isBeingDecrypted()) {
|
|
await lastReplacement.getDecryptionPromise();
|
|
}
|
|
return lastReplacement;
|
|
}
|
|
|
|
/*
|
|
* @param targetEvent - the event the relations are related to.
|
|
*/
|
|
async setTargetEvent(event) {
|
|
if (this.targetEvent) {
|
|
return;
|
|
}
|
|
this.targetEvent = event;
|
|
if (this.relationType === _event2.RelationType.Replace && !this.targetEvent.isState()) {
|
|
const replacement = await this.getLastReplacement();
|
|
// this is the initial update, so only call it if we already have something
|
|
// to not emit Event.replaced needlessly
|
|
if (replacement) {
|
|
this.targetEvent.makeReplaced(replacement);
|
|
}
|
|
}
|
|
this.maybeEmitCreated();
|
|
}
|
|
maybeEmitCreated() {
|
|
if (this.creationEmitted) {
|
|
return;
|
|
}
|
|
// Only emit we're "created" once we have a target event instance _and_
|
|
// at least one related event.
|
|
if (!this.targetEvent || !this.relations.size) {
|
|
return;
|
|
}
|
|
this.creationEmitted = true;
|
|
this.targetEvent.emit(_event.MatrixEventEvent.RelationsCreated, this.relationType, this.eventType);
|
|
}
|
|
}
|
|
exports.Relations = Relations;
|
|
//# sourceMappingURL=relations.js.map
|