@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/models/relations-container.js

@@ -0,0 +1,132 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+Copyright 2022 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.
+*/
+
+import { Relations } from "./relations.js";
+import { EventStatus, MatrixEventEvent } from "./event.js";
+export class RelationsContainer {
+  constructor(client, room) {
+    this.client = client;
+    this.room = room;
+    // A tree of objects to access a set of related children for an event, as in:
+    // this.relations.get(parentEventId).get(relationType).get(relationEventType)
+    _defineProperty(this, "relations", new Map());
+  }
+
+  /**
+   * Get a collection of child events to a given event in this timeline set.
+   *
+   * @param eventId - The ID of the event that you'd like to access child events for.
+   * For example, with annotations, this would be the ID of the event being annotated.
+   * @param relationType - The type of relationship involved, such as "m.annotation", "m.reference", "m.replace", etc.
+   * @param eventType - The relation event's type, such as "m.reaction", etc.
+   * @throws If `eventId</code>, <code>relationType</code> or <code>eventType`
+   * are not valid.
+   *
+   * @returns
+   * A container for relation events or undefined if there are no relation events for
+   * the relationType.
+   */
+  getChildEventsForEvent(eventId, relationType, eventType) {
+    var _this$relations$get;
+    return (_this$relations$get = this.relations.get(eventId)) === null || _this$relations$get === void 0 || (_this$relations$get = _this$relations$get.get(relationType)) === null || _this$relations$get === void 0 ? void 0 : _this$relations$get.get(eventType);
+  }
+  getAllChildEventsForEvent(parentEventId) {
+    var _this$relations$get2;
+    var relationsForEvent = (_this$relations$get2 = this.relations.get(parentEventId)) !== null && _this$relations$get2 !== void 0 ? _this$relations$get2 : new Map();
+    var events = [];
+    for (var relationsRecord of relationsForEvent.values()) {
+      for (var relations of relationsRecord.values()) {
+        events.push(...relations.getRelations());
+      }
+    }
+    return events;
+  }
+
+  /**
+   * Set an event as the target event if any Relations exist for it already.
+   * Child events can point to other child events as their parent, so this method may be
+   * called for events which are also logically child events.
+   *
+   * @param event - The event to check as relation target.
+   */
+  aggregateParentEvent(event) {
+    var relationsForEvent = this.relations.get(event.getId());
+    if (!relationsForEvent) return;
+    for (var relationsWithRelType of relationsForEvent.values()) {
+      for (var relationsWithEventType of relationsWithRelType.values()) {
+        relationsWithEventType.setTargetEvent(event);
+      }
+    }
+  }
+
+  /**
+   * Add relation events to the relevant relation collection.
+   *
+   * @param event - The new child event to be aggregated.
+   * @param timelineSet - The event timeline set within which to search for the related event if any.
+   */
+  aggregateChildEvent(event, timelineSet) {
+    if (event.isRedacted() || event.status === EventStatus.CANCELLED) {
+      return;
+    }
+    var relation = event.getRelation();
+    if (!relation) return;
+    var onEventDecrypted = () => {
+      if (event.isDecryptionFailure()) {
+        // This could for example happen if the encryption keys are not yet available.
+        // The event may still be decrypted later. Register the listener again.
+        event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
+        return;
+      }
+      this.aggregateChildEvent(event, timelineSet);
+    };
+
+    // If the event is currently encrypted, wait until it has been decrypted.
+    if (event.isBeingDecrypted() || event.shouldAttemptDecryption()) {
+      event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
+      return;
+    }
+    var {
+      event_id: relatesToEventId,
+      rel_type: relationType
+    } = relation;
+    var eventType = event.getType();
+    var relationsForEvent = this.relations.get(relatesToEventId);
+    if (!relationsForEvent) {
+      relationsForEvent = new Map();
+      this.relations.set(relatesToEventId, relationsForEvent);
+    }
+    var relationsWithRelType = relationsForEvent.get(relationType);
+    if (!relationsWithRelType) {
+      relationsWithRelType = new Map();
+      relationsForEvent.set(relationType, relationsWithRelType);
+    }
+    var relationsWithEventType = relationsWithRelType.get(eventType);
+    if (!relationsWithEventType) {
+      var _this$room, _ref, _timelineSet$findEven;
+      relationsWithEventType = new Relations(relationType, eventType, this.client);
+      relationsWithRelType.set(eventType, relationsWithEventType);
+      var _room = (_this$room = this.room) !== null && _this$room !== void 0 ? _this$room : timelineSet === null || timelineSet === void 0 ? void 0 : timelineSet.room;
+      var relatesToEvent = (_ref = (_timelineSet$findEven = timelineSet === null || timelineSet === void 0 ? void 0 : timelineSet.findEventById(relatesToEventId)) !== null && _timelineSet$findEven !== void 0 ? _timelineSet$findEven : _room === null || _room === void 0 ? void 0 : _room.findEventById(relatesToEventId)) !== null && _ref !== void 0 ? _ref : _room === null || _room === void 0 ? void 0 : _room.getPendingEvent(relatesToEventId);
+      if (relatesToEvent) {
+        relationsWithEventType.setTargetEvent(relatesToEvent);
+      }
+    }
+    relationsWithEventType.addEvent(event);
+  }
+}
+//# sourceMappingURL=relations-container.js.map

package/lib/models/relations-container.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations-container.js","names":["Relations","EventStatus","MatrixEventEvent","RelationsContainer","constructor","client","room","_defineProperty","Map","getChildEventsForEvent","eventId","relationType","eventType","_this$relations$get","relations","get","getAllChildEventsForEvent","parentEventId","_this$relations$get2","relationsForEvent","events","relationsRecord","values","push","getRelations","aggregateParentEvent","event","getId","relationsWithRelType","relationsWithEventType","setTargetEvent","aggregateChildEvent","timelineSet","isRedacted","status","CANCELLED","relation","getRelation","onEventDecrypted","isDecryptionFailure","once","Decrypted","isBeingDecrypted","shouldAttemptDecryption","event_id","relatesToEventId","rel_type","getType","set","_this$room","_ref","_timelineSet$findEven","relatesToEvent","findEventById","getPendingEvent","addEvent"],"sources":["../../src/models/relations-container.ts"],"sourcesContent":["/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { Relations } from \"./relations.ts\";\nimport { EventType, RelationType } from \"../@types/event.ts\";\nimport { EventStatus, MatrixEvent, MatrixEventEvent } from \"./event.ts\";\nimport { EventTimelineSet } from \"./event-timeline-set.ts\";\nimport { MatrixClient } from \"../client.ts\";\nimport { Room } from \"./room.ts\";\n\nexport class RelationsContainer {\n    // A tree of objects to access a set of related children for an event, as in:\n    // this.relations.get(parentEventId).get(relationType).get(relationEventType)\n    private relations = new Map<string, Map<RelationType | string, Map<EventType | string, Relations>>>();\n\n    public constructor(\n        private readonly client: MatrixClient,\n        private readonly room?: Room,\n    ) {}\n\n    /**\n     * Get a collection of child events to a given event in this timeline set.\n     *\n     * @param eventId - The ID of the event that you'd like to access child events for.\n     * For example, with annotations, this would be the ID of the event being annotated.\n     * @param relationType - The type of relationship involved, such as \"m.annotation\", \"m.reference\", \"m.replace\", etc.\n     * @param eventType - The relation event's type, such as \"m.reaction\", etc.\n     * @throws If `eventId</code>, <code>relationType</code> or <code>eventType`\n     * are not valid.\n     *\n     * @returns\n     * A container for relation events or undefined if there are no relation events for\n     * the relationType.\n     */\n    public getChildEventsForEvent(\n        eventId: string,\n        relationType: RelationType | string,\n        eventType: EventType | string,\n    ): Relations | undefined {\n        return this.relations.get(eventId)?.get(relationType)?.get(eventType);\n    }\n\n    public getAllChildEventsForEvent(parentEventId: string): MatrixEvent[] {\n        const relationsForEvent =\n            this.relations.get(parentEventId) ?? new Map<RelationType | string, Map<EventType | string, Relations>>();\n        const events: MatrixEvent[] = [];\n        for (const relationsRecord of relationsForEvent.values()) {\n            for (const relations of relationsRecord.values()) {\n                events.push(...relations.getRelations());\n            }\n        }\n        return events;\n    }\n\n    /**\n     * Set an event as the target event if any Relations exist for it already.\n     * Child events can point to other child events as their parent, so this method may be\n     * called for events which are also logically child events.\n     *\n     * @param event - The event to check as relation target.\n     */\n    public aggregateParentEvent(event: MatrixEvent): void {\n        const relationsForEvent = this.relations.get(event.getId()!);\n        if (!relationsForEvent) return;\n\n        for (const relationsWithRelType of relationsForEvent.values()) {\n            for (const relationsWithEventType of relationsWithRelType.values()) {\n                relationsWithEventType.setTargetEvent(event);\n            }\n        }\n    }\n\n    /**\n     * Add relation events to the relevant relation collection.\n     *\n     * @param event - The new child event to be aggregated.\n     * @param timelineSet - The event timeline set within which to search for the related event if any.\n     */\n    public aggregateChildEvent(event: MatrixEvent, timelineSet?: EventTimelineSet): void {\n        if (event.isRedacted() || event.status === EventStatus.CANCELLED) {\n            return;\n        }\n\n        const relation = event.getRelation();\n        if (!relation) return;\n\n        const onEventDecrypted = (): void => {\n            if (event.isDecryptionFailure()) {\n                // This could for example happen if the encryption keys are not yet available.\n                // The event may still be decrypted later. Register the listener again.\n                event.once(MatrixEventEvent.Decrypted, onEventDecrypted);\n                return;\n            }\n\n            this.aggregateChildEvent(event, timelineSet);\n        };\n\n        // If the event is currently encrypted, wait until it has been decrypted.\n        if (event.isBeingDecrypted() || event.shouldAttemptDecryption()) {\n            event.once(MatrixEventEvent.Decrypted, onEventDecrypted);\n            return;\n        }\n\n        const { event_id: relatesToEventId, rel_type: relationType } = relation;\n        const eventType = event.getType();\n\n        let relationsForEvent = this.relations.get(relatesToEventId!);\n        if (!relationsForEvent) {\n            relationsForEvent = new Map<RelationType | string, Map<EventType | string, Relations>>();\n            this.relations.set(relatesToEventId!, relationsForEvent);\n        }\n\n        let relationsWithRelType = relationsForEvent.get(relationType!);\n        if (!relationsWithRelType) {\n            relationsWithRelType = new Map<EventType | string, Relations>();\n            relationsForEvent.set(relationType!, relationsWithRelType);\n        }\n\n        let relationsWithEventType = relationsWithRelType.get(eventType);\n        if (!relationsWithEventType) {\n            relationsWithEventType = new Relations(relationType!, eventType, this.client);\n            relationsWithRelType.set(eventType, relationsWithEventType);\n\n            const room = this.room ?? timelineSet?.room;\n            const relatesToEvent =\n                timelineSet?.findEventById(relatesToEventId!) ??\n                room?.findEventById(relatesToEventId!) ??\n                room?.getPendingEvent(relatesToEventId!);\n            if (relatesToEvent) {\n                relationsWithEventType.setTargetEvent(relatesToEvent);\n            }\n        }\n\n        relationsWithEventType.addEvent(event);\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/models/relations.d.ts

@@ -0,0 +1,114 @@
+import { MatrixEvent } from "./event.ts";
+import { RelationType } from "../@types/event.ts";
+import { TypedEventEmitter } from "./typed-event-emitter.ts";
+import { MatrixClient } from "../client.ts";
+import { Room } from "./room.ts";
+export declare enum RelationsEvent {
+    Add = "Relations.add",
+    Remove = "Relations.remove",
+    Redaction = "Relations.redaction"
+}
+export type EventHandlerMap = {
+    [RelationsEvent.Add]: (event: MatrixEvent) => void;
+    [RelationsEvent.Remove]: (event: MatrixEvent) => void;
+    [RelationsEvent.Redaction]: (event: MatrixEvent) => void;
+};
+/**
+ * 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.
+ */
+export declare class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap> {
+    readonly relationType: RelationType | string;
+    readonly eventType: string;
+    readonly altEventTypes?: string[] | undefined;
+    private relationEventIds;
+    private relations;
+    private annotationsByKey;
+    private annotationsBySender;
+    private sortedAnnotationsByKey;
+    private targetEvent;
+    private creationEmitted;
+    private readonly client;
+    /**
+     * @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: RelationType | string, eventType: string, client: MatrixClient | Room, altEventTypes?: string[] | undefined);
+    /**
+     * Add relation events to this collection.
+     *
+     * @param event - The new relation event to be added.
+     */
+    addEvent(event: MatrixEvent): Promise<void>;
+    /**
+     * Remove relation event from this collection.
+     *
+     * @param event - The relation event to remove.
+     */
+    removeEvent(event: MatrixEvent): Promise<void>;
+    /**
+     * Listens for event status changes to remove cancelled events.
+     *
+     * @param event - The event whose status has changed
+     * @param status - The new status
+     */
+    private onEventStatus;
+    /**
+     * 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(): MatrixEvent[];
+    private addAnnotationToAggregation;
+    private removeAnnotationFromAggregation;
+    /**
+     * 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.
+     */
+    private onBeforeRedaction;
+    /**
+     * 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(): [string, Set<MatrixEvent>][] | null;
+    /**
+     * 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(): Record<string, Set<MatrixEvent>> | null;
+    /**
+     * 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`.
+     */
+    getLastReplacement(): Promise<MatrixEvent | null>;
+    setTargetEvent(event: MatrixEvent): Promise<void>;
+    private maybeEmitCreated;
+}
+//# sourceMappingURL=relations.d.ts.map

package/lib/models/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../src/models/relations.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAoC,WAAW,EAAoB,MAAM,YAAY,CAAC;AAE7F,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,oBAAY,cAAc;IACtB,GAAG,kBAAkB;IACrB,MAAM,qBAAqB;IAC3B,SAAS,wBAAwB;CACpC;AAED,MAAM,MAAM,eAAe,GAAG;IAC1B,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACnD,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACtD,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CAC5D,CAAC;AAKF;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,iBAAiB,CAAC,cAAc,EAAE,eAAe,CAAC;aAiBzD,YAAY,EAAE,YAAY,GAAG,MAAM;aACnC,SAAS,EAAE,MAAM;aAEjB,aAAa,CAAC,EAAE,MAAM,EAAE;IAnB5C,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,gBAAgB,CAAwC;IAChE,OAAO,CAAC,mBAAmB,CAAwC;IACnE,OAAO,CAAC,sBAAsB,CAAoC;IAClE,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IAEtC;;;;;OAKG;gBAEiB,YAAY,EAAE,YAAY,GAAG,MAAM,EACnC,SAAS,EAAE,MAAM,EACjC,MAAM,EAAE,YAAY,GAAG,IAAI,EACX,aAAa,CAAC,EAAE,MAAM,EAAE,YAAA;IAM5C;;;;OAIG;IACU,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA0CxD;;;;OAIG;IACU,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB3D;;;;;OAKG;IACH,OAAO,CAAC,aAAa,CAYnB;IAEF;;;;;;;;OAQG;IACI,YAAY,IAAI,WAAW,EAAE;IAIpC,OAAO,CAAC,0BAA0B;IA2BlC,OAAO,CAAC,+BAA+B;IAuBvC;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB,CAkBvB;IAEF;;;;;;;;OAQG;IACI,yBAAyB,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,GAAG,IAAI;IASvE;;;;;;;OAOG;IACI,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IASxE;;;;;OAKG;IACU,kBAAkB,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IA0CjD,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB9D,OAAO,CAAC,gBAAgB;CAY3B"}

package/lib/models/relations.js

@@ -0,0 +1,354 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+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.
+*/
+
+import { EventStatus, MatrixEventEvent } from "./event.js";
+import { logger } from "../logger.js";
+import { RelationType } from "../@types/event.js";
+import { TypedEventEmitter } from "./typed-event-emitter.js";
+import { Room } from "./room.js";
+export var RelationsEvent = /*#__PURE__*/function (RelationsEvent) {
+  RelationsEvent["Add"] = "Relations.add";
+  RelationsEvent["Remove"] = "Relations.remove";
+  RelationsEvent["Redaction"] = "Relations.redaction";
+  return RelationsEvent;
+}({});
+var matchesEventType = function matchesEventType(eventType, targetEventType) {
+  var altTargetEventTypes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  return [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.
+ */
+export class Relations extends 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) {
+    var _this;
+    super();
+    _this = this;
+    this.relationType = relationType;
+    this.eventType = eventType;
+    this.altEventTypes = altEventTypes;
+    _defineProperty(this, "relationEventIds", new Set());
+    _defineProperty(this, "relations", new Set());
+    _defineProperty(this, "annotationsByKey", {});
+    _defineProperty(this, "annotationsBySender", {});
+    _defineProperty(this, "sortedAnnotationsByKey", []);
+    _defineProperty(this, "targetEvent", null);
+    _defineProperty(this, "creationEmitted", false);
+    _defineProperty(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
+     */
+    _defineProperty(this, "onEventStatus", (event, status) => {
+      if (!event.isSending()) {
+        // Sending is done, so we don't need to listen anymore
+        event.removeListener(MatrixEventEvent.Status, this.onEventStatus);
+        return;
+      }
+      if (status !== EventStatus.CANCELLED) {
+        return;
+      }
+      // Event was cancelled, remove from the collection
+      event.removeListener(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.
+     */
+    _defineProperty(this, "onBeforeRedaction", /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (redactedEvent) {
+        if (!_this.relations.has(redactedEvent)) {
+          return;
+        }
+        _this.relations.delete(redactedEvent);
+        if (_this.relationType === RelationType.Annotation) {
+          // Remove the redacted annotation from aggregation by key
+          _this.removeAnnotationFromAggregation(redactedEvent);
+        } else if (_this.relationType === RelationType.Replace && _this.targetEvent && !_this.targetEvent.isState()) {
+          var lastReplacement = yield _this.getLastReplacement();
+          _this.targetEvent.makeReplaced(lastReplacement);
+        }
+        redactedEvent.removeListener(MatrixEventEvent.BeforeRedaction, _this.onBeforeRedaction);
+        _this.emit(RelationsEvent.Redaction, redactedEvent);
+      });
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    this.client = client instanceof Room ? client.client : client;
+  }
+
+  /**
+   * Add relation events to this collection.
+   *
+   * @param event - The new relation event to be added.
+   */
+  addEvent(event) {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      if (_this2.relationEventIds.has(event.getId())) {
+        return;
+      }
+      var relation = event.getRelation();
+      if (!relation) {
+        logger.error("Event must have relation info");
+        return;
+      }
+      var relationType = relation.rel_type;
+      var eventType = event.getType();
+      if (_this2.relationType !== relationType || !matchesEventType(eventType, _this2.eventType, _this2.altEventTypes)) {
+        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(MatrixEventEvent.Status, _this2.onEventStatus);
+      }
+      _this2.relations.add(event);
+      _this2.relationEventIds.add(event.getId());
+      if (_this2.relationType === RelationType.Annotation) {
+        _this2.addAnnotationToAggregation(event);
+      } else if (_this2.relationType === RelationType.Replace && _this2.targetEvent && !_this2.targetEvent.isState()) {
+        var lastReplacement = yield _this2.getLastReplacement();
+        _this2.targetEvent.makeReplaced(lastReplacement);
+      }
+      event.on(MatrixEventEvent.BeforeRedaction, _this2.onBeforeRedaction);
+      _this2.emit(RelationsEvent.Add, event);
+      _this2.maybeEmitCreated();
+    })();
+  }
+
+  /**
+   * Remove relation event from this collection.
+   *
+   * @param event - The relation event to remove.
+   */
+  removeEvent(event) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      if (!_this3.relations.has(event)) {
+        return;
+      }
+      _this3.relations.delete(event);
+      if (_this3.relationType === RelationType.Annotation) {
+        _this3.removeAnnotationFromAggregation(event);
+      } else if (_this3.relationType === RelationType.Replace && _this3.targetEvent && !_this3.targetEvent.isState()) {
+        var lastReplacement = yield _this3.getLastReplacement();
+        _this3.targetEvent.makeReplaced(lastReplacement);
+      }
+      _this3.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;
+    var {
+      key
+    } = (_event$getRelation = event.getRelation()) !== null && _event$getRelation !== void 0 ? _event$getRelation : {};
+    if (!key) return;
+    var 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) => {
+      var aEvents = a[1];
+      var bEvents = b[1];
+      return bEvents.size - aEvents.size;
+    });
+    var sender = event.getSender();
+    var 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;
+    var {
+      key
+    } = (_event$getRelation2 = event.getRelation()) !== null && _event$getRelation2 !== void 0 ? _event$getRelation2 : {};
+    if (!key) return;
+    var 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) => {
+        var aEvents = a[1];
+        var bEvents = b[1];
+        return bEvents.size - aEvents.size;
+      });
+    }
+    var sender = event.getSender();
+    var 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 !== 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 !== 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`.
+   */
+  getLastReplacement() {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      if (_this4.relationType !== RelationType.Replace) {
+        // Aggregating on last only makes sense for this relation type
+        return null;
+      }
+      if (!_this4.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
+      var replaceRelation = _this4.targetEvent.getServerAggregatedRelation(RelationType.Replace);
+      var minTs = replaceRelation === null || replaceRelation === void 0 ? void 0 : replaceRelation.origin_server_ts;
+      var lastReplacement = _this4.getRelations().reduce((last, event) => {
+        if (event.getSender() !== _this4.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() && _this4.client.isCryptoEnabled()) {
+        yield lastReplacement.attemptDecryption(_this4.client.crypto);
+      } else if (lastReplacement !== null && lastReplacement !== void 0 && lastReplacement.isBeingDecrypted()) {
+        yield lastReplacement.getDecryptionPromise();
+      }
+      return lastReplacement;
+    })();
+  }
+
+  /*
+   * @param targetEvent - the event the relations are related to.
+   */
+  setTargetEvent(event) {
+    var _this5 = this;
+    return _asyncToGenerator(function* () {
+      if (_this5.targetEvent) {
+        return;
+      }
+      _this5.targetEvent = event;
+      if (_this5.relationType === RelationType.Replace && !_this5.targetEvent.isState()) {
+        var replacement = yield _this5.getLastReplacement();
+        // this is the initial update, so only call it if we already have something
+        // to not emit Event.replaced needlessly
+        if (replacement) {
+          _this5.targetEvent.makeReplaced(replacement);
+        }
+      }
+      _this5.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(MatrixEventEvent.RelationsCreated, this.relationType, this.eventType);
+  }
+}
+//# sourceMappingURL=relations.js.map