feat: complete Ancestor quote bot with production-ready Docker support

node_modules/matrix-js-sdk/lib/models/relations-container.js

@@ -1,4 +1,13 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RelationsContainer = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _relations = require("./relations");
+var _event = require("./event");
 /*
 Copyright 2022 The Matrix.org Foundation C.I.C.
 
@@ -15,16 +24,13 @@ 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";
-import { logger } from "../logger.js";
-export class RelationsContainer {
+class RelationsContainer {
   constructor(client, 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());
     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)
+    (0, _defineProperty2.default)(this, "relations", new Map());
   }
 
   /**
@@ -42,10 +48,12 @@ export class RelationsContainer {
    * the relationType.
    */
   getChildEventsForEvent(eventId, relationType, eventType) {
-    return this.relations.get(eventId)?.get(relationType)?.get(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) {
-    const relationsForEvent = this.relations.get(parentEventId) ?? new Map();
+    var _this$relations$get2;
+    const relationsForEvent = (_this$relations$get2 = this.relations.get(parentEventId)) !== null && _this$relations$get2 !== void 0 ? _this$relations$get2 : new Map();
     const events = [];
     for (const relationsRecord of relationsForEvent.values()) {
       for (const relations of relationsRecord.values()) {
@@ -78,42 +86,26 @@ export class RelationsContainer {
    * @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.
    */
-
-  /**
-   * Add a relation event using a known target that is not in the timeline yet.
-   *
-   * @param event - The new child event to be aggregated.
-   * @param timelineSet - The event timeline set within which to search for the related event.
-   * @param targetEvent - The known relation target.
-   * @returns A promise which resolves after aggregation.
-   */
-
-  aggregateChildEvent(event, timelineSet, targetEvent) {
-    const aggregation = this.aggregateChildEventInternal(event, timelineSet, targetEvent);
-    if (targetEvent) return aggregation;
-    void aggregation.catch(error => logger.error("Failed to aggregate child event: ", error));
-  }
-  aggregateChildEventInternal(event, timelineSet, targetEvent) {
-    if (event.isRedacted() || event.status === EventStatus.CANCELLED) {
-      return Promise.resolve();
+  aggregateChildEvent(event, timelineSet) {
+    if (event.isRedacted() || event.status === _event.EventStatus.CANCELLED) {
+      return;
     }
     const relation = event.getRelation();
-    if (!relation) return Promise.resolve();
+    if (!relation) return;
+    const 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(_event.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()) {
-      return new Promise((resolve, reject) => {
-        const 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;
-          }
-          void this.aggregateChildEventInternal(event, timelineSet, targetEvent).then(resolve, reject);
-        };
-        event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
-      });
+      event.once(_event.MatrixEventEvent.Decrypted, onEventDecrypted);
+      return;
     }
     const {
       event_id: relatesToEventId,
@@ -131,21 +123,18 @@ export class RelationsContainer {
       relationsForEvent.set(relationType, relationsWithRelType);
     }
     let relationsWithEventType = relationsWithRelType.get(eventType);
-    const isNewRelationCollection = !relationsWithEventType;
-    let targetEventUpdate = Promise.resolve();
     if (!relationsWithEventType) {
-      relationsWithEventType = new Relations(relationType, eventType, this.client);
+      var _this$room, _ref, _timelineSet$findEven;
+      relationsWithEventType = new _relations.Relations(relationType, eventType, this.client);
       relationsWithRelType.set(eventType, relationsWithEventType);
-    }
-    if (isNewRelationCollection || targetEvent) {
-      const room = this.room ?? timelineSet?.room;
-      const relatesToEvent = timelineSet?.findEventById(relatesToEventId) ?? room?.findEventById(relatesToEventId) ?? room?.getPendingEvent(relatesToEventId) ?? targetEvent;
+      const room = (_this$room = this.room) !== null && _this$room !== void 0 ? _this$room : timelineSet === null || timelineSet === void 0 ? void 0 : timelineSet.room;
+      const 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) {
-        targetEventUpdate = relationsWithEventType.setTargetEvent(relatesToEvent);
+        relationsWithEventType.setTargetEvent(relatesToEvent);
       }
     }
-    const addEventUpdate = relationsWithEventType.addEvent(event);
-    return Promise.all([targetEventUpdate, addEventUpdate]).then(() => undefined);
+    relationsWithEventType.addEvent(event);
   }
 }
+exports.RelationsContainer = RelationsContainer;
 //# sourceMappingURL=relations-container.js.map