@unwanted/matrix-sdk-mini 34.12.0 → 34.13.0

package/lib/sliding-sync-sdk.js

@@ -1,5 +1,5 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /*
 Copyright 2022 The Matrix.org Foundation C.I.C.
 
@@ -21,7 +21,7 @@ import { logger } from "./logger.js";
 import { promiseMapSeries } from "./utils.js";
 import { EventTimeline } from "./models/event-timeline.js";
 import { ClientEvent } from "./client.js";
-import { SyncState, _createAndReEmitRoom, defaultClientOpts, defaultSyncApiOpts } from "./sync.js";
+import { SyncState, _createAndReEmitRoom, defaultClientOpts } from "./sync.js";
 import { MatrixError } from "./http-api/index.js";
 import { ExtensionState, SlidingSyncEvent, SlidingSyncState } from "./sliding-sync.js";
 import { EventType } from "./@types/event.js";
@@ -33,42 +33,9 @@ import { KnownMembership } from "./@types/membership.js";
 // to RECONNECTING. This is needed to inform the client of server issues when the
 // keepAlive is successful but the server /sync fails.
 var FAILED_SYNC_ERROR_THRESHOLD = 3;
-class ExtensionE2EE {
-  constructor(crypto) {
-    this.crypto = crypto;
-  }
-  name() {
-    return "e2ee";
-  }
-  when() {
-    return ExtensionState.PreProcess;
-  }
-  onRequest(isInitial) {
-    if (!isInitial) {
-      return undefined;
-    }
-    return {
-      enabled: true // this is sticky so only send it on the initial request
-    };
-  }
-  onResponse(data) {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      // Handle device list updates
-      if (data.device_lists) {
-        yield _this.crypto.processDeviceLists(data.device_lists);
-      }
-
-      // Handle one_time_keys_count and unused_fallback_key_types
-      yield _this.crypto.processKeyCounts(data.device_one_time_keys_count, data["device_unused_fallback_key_types"] || data["org.matrix.msc2732.device_unused_fallback_key_types"]);
-      _this.crypto.onSyncCompleted({});
-    })();
-  }
-}
 class ExtensionToDevice {
-  constructor(client, cryptoCallbacks) {
+  constructor(client) {
     this.client = client;
-    this.cryptoCallbacks = cryptoCallbacks;
     _defineProperty(this, "nextBatch", null);
   }
   name() {
@@ -88,14 +55,11 @@ class ExtensionToDevice {
     return extReq;
   }
   onResponse(data) {
-    var _this2 = this;
+    var _this = this;
     return _asyncToGenerator(function* () {
       var cancelledKeyVerificationTxns = [];
       var events = data["events"] || [];
-      if (events.length > 0 && _this2.cryptoCallbacks) {
-        events = yield _this2.cryptoCallbacks.preprocessToDeviceMessages(events);
-      }
-      events.map(_this2.client.getEventMapper()).map(toDeviceEvent => {
+      events.map(_this.client.getEventMapper()).map(toDeviceEvent => {
         // map is a cheap inline forEach
         // We want to flag m.key.verification.start events as cancelled
         // if there's an accompanying m.key.verification.cancel event, so
@@ -125,9 +89,9 @@ class ExtensionToDevice {
             toDeviceEvent.flagCancelled();
           }
         }
-        _this2.client.emit(ClientEvent.ToDeviceEvent, toDeviceEvent);
+        _this.client.emit(ClientEvent.ToDeviceEvent, toDeviceEvent);
       });
-      _this2.nextBatch = data.next_batch;
+      _this.nextBatch = data.next_batch;
     })();
   }
 }
@@ -150,21 +114,21 @@ class ExtensionAccountData {
     };
   }
   onResponse(data) {
-    var _this3 = this;
+    var _this2 = this;
     return _asyncToGenerator(function* () {
       if (data.global && data.global.length > 0) {
-        _this3.processGlobalAccountData(data.global);
+        _this2.processGlobalAccountData(data.global);
       }
       for (var roomId in data.rooms) {
-        var accountDataEvents = mapEvents(_this3.client, roomId, data.rooms[roomId]);
-        var room = _this3.client.getRoom(roomId);
+        var accountDataEvents = mapEvents(_this2.client, roomId, data.rooms[roomId]);
+        var room = _this2.client.getRoom(roomId);
         if (!room) {
           logger.warn("got account data for room but room doesn't exist on client:", roomId);
           continue;
         }
         room.addAccountData(accountDataEvents);
         accountDataEvents.forEach(e => {
-          _this3.client.emit(ClientEvent.Event, e);
+          _this2.client.emit(ClientEvent.Event, e);
         });
       }
     })();
@@ -210,13 +174,13 @@ class ExtensionTyping {
     };
   }
   onResponse(data) {
-    var _this4 = this;
+    var _this3 = this;
     return _asyncToGenerator(function* () {
       if (!(data !== null && data !== void 0 && data.rooms)) {
         return;
       }
       for (var roomId in data.rooms) {
-        processEphemeralEvents(_this4.client, roomId, [data.rooms[roomId]]);
+        processEphemeralEvents(_this3.client, roomId, [data.rooms[roomId]]);
       }
     })();
   }
@@ -240,13 +204,13 @@ class ExtensionReceipts {
     return undefined; // don't send a JSON object for subsequent requests, we don't need to.
   }
   onResponse(data) {
-    var _this5 = this;
+    var _this4 = this;
     return _asyncToGenerator(function* () {
       if (!(data !== null && data !== void 0 && data.rooms)) {
         return;
       }
       for (var roomId in data.rooms) {
-        processEphemeralEvents(_this5.client, roomId, [data.rooms[roomId]]);
+        processEphemeralEvents(_this4.client, roomId, [data.rooms[roomId]]);
       }
     })();
   }
@@ -259,43 +223,38 @@ class ExtensionReceipts {
 export class SlidingSyncSdk {
   // accumulator of sync events in the current sync response
 
-  constructor(slidingSync, client, opts, syncOpts) {
+  constructor(slidingSync, client, opts) {
     this.slidingSync = slidingSync;
     this.client = client;
     _defineProperty(this, "opts", void 0);
-    _defineProperty(this, "syncOpts", void 0);
     _defineProperty(this, "syncState", null);
     _defineProperty(this, "syncStateData", void 0);
     _defineProperty(this, "lastPos", null);
     _defineProperty(this, "failCount", 0);
     _defineProperty(this, "notifEvents", []);
     this.opts = defaultClientOpts(opts);
-    this.syncOpts = defaultSyncApiOpts(syncOpts);
     if (client.getNotifTimelineSet()) {
       client.reEmitter.reEmit(client.getNotifTimelineSet(), [RoomEvent.Timeline, RoomEvent.TimelineReset]);
     }
     this.slidingSync.on(SlidingSyncEvent.Lifecycle, this.onLifecycle.bind(this));
     this.slidingSync.on(SlidingSyncEvent.RoomData, this.onRoomData.bind(this));
-    var extensions = [new ExtensionToDevice(this.client, this.syncOpts.cryptoCallbacks), new ExtensionAccountData(this.client), new ExtensionTyping(this.client), new ExtensionReceipts(this.client)];
-    if (this.syncOpts.crypto) {
-      extensions.push(new ExtensionE2EE(this.syncOpts.crypto));
-    }
+    var extensions = [new ExtensionToDevice(this.client), new ExtensionAccountData(this.client), new ExtensionTyping(this.client), new ExtensionReceipts(this.client)];
     extensions.forEach(ext => {
       this.slidingSync.registerExtension(ext);
     });
   }
   onRoomData(roomId, roomData) {
-    var _this6 = this;
+    var _this5 = this;
     return _asyncToGenerator(function* () {
-      var room = _this6.client.store.getRoom(roomId);
+      var room = _this5.client.store.getRoom(roomId);
       if (!room) {
         if (!roomData.initial) {
           logger.debug("initial flag not set but no stored room exists for room ", roomId, roomData);
           return;
         }
-        room = _createAndReEmitRoom(_this6.client, roomId, _this6.opts);
+        room = _createAndReEmitRoom(_this5.client, roomId, _this5.opts);
       }
-      yield _this6.processRoomData(_this6.client, room, roomData);
+      yield _this5.processRoomData(_this5.client, room, roomData);
     })();
   }
   onLifecycle(state, resp, err) {
@@ -452,15 +411,15 @@ export class SlidingSyncSdk {
     return false;
   }
   processRoomData(client, room, roomData) {
-    var _this7 = this;
+    var _this6 = this;
     return _asyncToGenerator(function* () {
       roomData = ensureNameEvent(client, room.roomId, roomData);
-      var stateEvents = mapEvents(_this7.client, room.roomId, roomData.required_state);
+      var stateEvents = mapEvents(_this6.client, room.roomId, roomData.required_state);
       // Prevent events from being decrypted ahead of time
       // this helps large account to speed up faster
       // room::decryptCriticalEvent is in charge of decrypting all the events
       // required for a client to function properly
-      var timelineEvents = mapEvents(_this7.client, room.roomId, roomData.timeline, false);
+      var timelineEvents = mapEvents(_this6.client, room.roomId, roomData.timeline, false);
       var ephemeralEvents = []; // TODO this.mapSyncEventsFormat(joinObj.ephemeral);
 
       // TODO: handle threaded / beacon events
@@ -501,7 +460,7 @@ export class SlidingSyncSdk {
         timelineEvents = newEvents;
         if (oldEvents.length > 0) {
           // old events are scrollback, insert them now
-          room.addEventsToTimeline(oldEvents, true, room.getLiveTimeline(), roomData.prev_batch);
+          room.addEventsToTimeline(oldEvents, true, false, room.getLiveTimeline(), roomData.prev_batch);
         }
       }
       var encrypted = room.hasEncryptionStateEvent();
@@ -525,15 +484,15 @@ export class SlidingSyncSdk {
         room.currentState.setJoinedMemberCount(roomData.joined_count);
       }
       if (roomData.invite_state) {
-        var inviteStateEvents = mapEvents(_this7.client, room.roomId, roomData.invite_state);
-        yield _this7.injectRoomEvents(room, inviteStateEvents);
+        var inviteStateEvents = mapEvents(_this6.client, room.roomId, roomData.invite_state);
+        yield _this6.injectRoomEvents(room, inviteStateEvents);
         if (roomData.initial) {
           room.recalculate();
-          _this7.client.store.storeRoom(room);
-          _this7.client.emit(ClientEvent.Room, room);
+          _this6.client.store.storeRoom(room);
+          _this6.client.emit(ClientEvent.Room, room);
         }
         inviteStateEvents.forEach(e => {
-          _this7.client.emit(ClientEvent.Event, e);
+          _this6.client.emit(ClientEvent.Event, e);
         });
         room.updateMyMembership(KnownMembership.Invite);
         return;
@@ -592,7 +551,7 @@ export class SlidingSyncSdk {
           }
       } */
 
-      yield _this7.injectRoomEvents(room, stateEvents, timelineEvents, roomData.num_live);
+      yield _this6.injectRoomEvents(room, stateEvents, timelineEvents, roomData.num_live);
 
       // we deliberately don't add ephemeral events to the timeline
       room.addEphemeralEvents(ephemeralEvents);
@@ -608,13 +567,10 @@ export class SlidingSyncSdk {
 
       // check if any timeline events should bing and add them to the notifEvents array:
       // we'll purge this once we've fully processed the sync response
-      _this7.addNotifications(timelineEvents);
+      _this6.addNotifications(timelineEvents);
       var processRoomEvent = /*#__PURE__*/function () {
         var _ref = _asyncToGenerator(function* (e) {
           client.emit(ClientEvent.Event, e);
-          if (e.isState() && e.getType() == EventType.RoomEncryption && _this7.syncOpts.cryptoCallbacks) {
-            yield _this7.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);
-          }
         });
         return function processRoomEvent(_x) {
           return _ref.apply(this, arguments);
@@ -625,30 +581,24 @@ export class SlidingSyncSdk {
       ephemeralEvents.forEach(function (e) {
         client.emit(ClientEvent.Event, e);
       });
-
-      // Decrypt only the last message in all rooms to make sure we can generate a preview
-      // And decrypt all events after the recorded read receipt to ensure an accurate
-      // notification count
-      room.decryptCriticalEvents();
     })();
   }
 
   /**
    * Injects events into a room's model.
    * @param stateEventList - A list of state events. This is the state
-   * at the *START* of the timeline list if it is supplied.
+   * at the *END* of the timeline list if it is supplied.
    * @param timelineEventList - A list of timeline events. Lower index
    * is earlier in time. Higher index is later.
    * @param numLive - the number of events in timelineEventList which just happened,
    * supplied from the server.
    */
-  injectRoomEvents(room, stateEventList, timelineEventList, numLive) {
-    var _this8 = this;
+  injectRoomEvents(room, stateEventList) {
+    var _arguments = arguments,
+      _this7 = this;
     return _asyncToGenerator(function* () {
-      timelineEventList = timelineEventList || [];
-      stateEventList = stateEventList || [];
-      numLive = numLive || 0;
-
+      var timelineEventList = _arguments.length > 2 && _arguments[2] !== undefined ? _arguments[2] : [];
+      var numLive = _arguments.length > 3 && _arguments[3] !== undefined ? _arguments[3] : 0;
       // If there are no events in the timeline yet, initialise it with
       // the given state events
       var liveTimeline = room.getLiveTimeline();
@@ -663,7 +613,7 @@ export class SlidingSyncSdk {
         // find some solution where MatrixEvents are immutable but allow for a cache
         // field.
         for (var ev of stateEventList) {
-          _this8.client.getPushActionsForEvent(ev);
+          _this7.client.getPushActionsForEvent(ev);
         }
         liveTimeline.initialiseState(stateEventList);
       }
@@ -699,22 +649,23 @@ export class SlidingSyncSdk {
         timelineEventList = timelineEventList.slice(0, -1 * liveTimelineEvents.length);
       }
 
-      // execute the timeline events. This will continue to diverge the current state
-      // if the timeline has any state events in it.
+      // Execute the timeline events.
       // This also needs to be done before running push rules on the events as they need
       // to be decorated with sender etc.
       yield room.addLiveEvents(timelineEventList, {
-        fromCache: true
+        fromCache: true,
+        addToState: false
       });
       if (liveTimelineEvents.length > 0) {
         yield room.addLiveEvents(liveTimelineEvents, {
-          fromCache: false
+          fromCache: false,
+          addToState: false
         });
       }
       room.recalculate();
 
       // resolve invites now we have set the latest state
-      _this8.resolveInvites(room);
+      _this7.resolveInvites(room);
     })();
   }
   resolveInvites(room) {
@@ -764,29 +715,29 @@ export class SlidingSyncSdk {
    * Main entry point. Blocks until stop() is called.
    */
   sync() {
-    var _this9 = this;
+    var _this8 = this;
     return _asyncToGenerator(function* () {
       logger.debug("Sliding sync init loop");
 
       //   1) We need to get push rules so we can check if events should bing as we get
       //      them from /sync.
-      while (!_this9.client.isGuest()) {
+      while (!_this8.client.isGuest()) {
         try {
           logger.debug("Getting push rules...");
-          var result = yield _this9.client.getPushRules();
+          var result = yield _this8.client.getPushRules();
           logger.debug("Got push rules");
-          _this9.client.pushRules = result;
+          _this8.client.pushRules = result;
           break;
         } catch (err) {
           logger.error("Getting push rules failed", err);
-          if (_this9.shouldAbortSync(err)) {
+          if (_this8.shouldAbortSync(err)) {
             return;
           }
         }
       }
 
       // start syncing
-      yield _this9.slidingSync.start();
+      yield _this8.slidingSync.start();
     })();
   }
 
@@ -844,7 +795,9 @@ export class SlidingSyncSdk {
     });
     this.notifEvents.forEach(event => {
       var _this$client$getNotif;
-      (_this$client$getNotif = this.client.getNotifTimelineSet()) === null || _this$client$getNotif === void 0 || _this$client$getNotif.addLiveEvent(event);
+      (_this$client$getNotif = this.client.getNotifTimelineSet()) === null || _this$client$getNotif === void 0 || _this$client$getNotif.addLiveEvent(event, {
+        addToState: false
+      });
     });
     this.notifEvents = [];
   }