matrix-js-sdk 37.2.0 → 37.3.0-rc.0

package/lib/sliding-sync.js

@@ -1,9 +1,7 @@
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /*
-Copyright 2022 The Matrix.org Foundation C.I.C.
+Copyright 2022-2024 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.
@@ -20,7 +18,7 @@ limitations under the License.
 
 import { logger } from "./logger.js";
 import { TypedEventEmitter } from "./models/typed-event-emitter.js";
-import { sleep, defer } from "./utils.js";
+import { sleep } from "./utils.js";
 // /sync requests allow you to set a timeout= but the request may continue
 // beyond that and wedge forever, so we need to track how long we are willing
 // to keep open the connection. This constant is *ADDED* to the timeout= value
@@ -46,6 +44,13 @@ export var MSC3575_STATE_KEY_LAZY = "$LAZY";
  * A complete Sliding Sync request.
  */
 
+/**
+ * New format of hero introduced in MSC4186 with display name and avatar URL
+ * in addition to just user_id (as it is on the wire, with underscores)
+ * as opposed to Hero in room-summary.ts which has fields in camelCase
+ * (and also a flag to note what format the hero came from).
+ */
+
 /**
  * A complete Sliding Sync response
  */
@@ -69,7 +74,6 @@ class SlidingList {
     _defineProperty(this, "list", void 0);
     _defineProperty(this, "isModified", void 0);
     // returned data
-    _defineProperty(this, "roomIndexToRoomId", {});
     _defineProperty(this, "joinedCount", 0);
     this.replaceList(list);
   }
@@ -105,9 +109,6 @@ class SlidingList {
     // reset values as the join count may be very different (if filters changed) including the rooms
     // (e.g. sort orders or sliding window ranges changed)
 
-    // the constantly changing sliding window ranges. Not an array for performance reasons
-    // E.g. tracking ranges 0-99, 500-599, we don't want to have a 600 element array
-    this.roomIndexToRoomId = {};
     // the total number of joined rooms according to the server, always >= len(roomIndexToRoomId)
     this.joinedCount = 0;
   }
@@ -127,26 +128,6 @@ class SlidingList {
     }
     return list;
   }
-
-  /**
-   * Check if a given index is within the list range. This is required even though the /sync API
-   * provides explicit updates with index positions because of the following situation:
-   *   0 1 2 3 4 5 6 7 8   indexes
-   *   a b c       d e f   COMMANDS: SYNC 0 2 a b c; SYNC 6 8 d e f;
-   *   a b c       d _ f   COMMAND: DELETE 7;
-   *   e a b c       d f   COMMAND: INSERT 0 e;
-   *   c=3 is wrong as we are not tracking it, ergo we need to see if `i` is in range else drop it
-   * @param i - The index to check
-   * @returns True if the index is within a sliding window
-   */
-  isIndexInRange(i) {
-    for (var r of this.list.ranges) {
-      if (r[0] <= i && i <= r[1]) {
-        return true;
-      }
-    }
-    return false;
-  }
 }
 
 /**
@@ -167,17 +148,14 @@ export var ExtensionState = /*#__PURE__*/function (ExtensionState) {
  * of information when processing sync responses.
  *  - RoomData: concerns rooms, useful for SlidingSyncSdk to update its knowledge of rooms.
  *  - Lifecycle: concerns callbacks at various well-defined points in the sync process.
- *  - List: concerns lists, useful for UI layers to re-render room lists.
  * Specifically, the order of event invocation is:
  *  - Lifecycle (state=RequestFinished)
  *  - RoomData (N times)
  *  - Lifecycle (state=Complete)
- *  - List (at most once per list)
  */
 export var SlidingSyncEvent = /*#__PURE__*/function (SlidingSyncEvent) {
   SlidingSyncEvent["RoomData"] = "SlidingSync.RoomData";
   SlidingSyncEvent["Lifecycle"] = "SlidingSync.Lifecycle";
-  SlidingSyncEvent["List"] = "SlidingSync.List";
   return SlidingSyncEvent;
 }({});
 /**
@@ -206,11 +184,6 @@ export class SlidingSync extends TypedEventEmitter {
     _defineProperty(this, "terminated", false);
     // flag set when resend() is called because we cannot rely on detecting AbortError in JS SDK :(
     _defineProperty(this, "needsResend", false);
-    // the txn_id to send with the next request.
-    _defineProperty(this, "txnId", null);
-    // a list (in chronological order of when they were sent) of objects containing the txn ID and
-    // a defer to resolve/reject depending on whether they were successfully sent or not.
-    _defineProperty(this, "txnIdDefers", []);
     // map of extension name to req/resp handler
     _defineProperty(this, "extensions", {});
     _defineProperty(this, "desiredRoomSubscriptions", new Set());
@@ -272,8 +245,7 @@ export class SlidingSync extends TypedEventEmitter {
       return null;
     }
     return {
-      joinedCount: data.joinedCount,
-      roomIndexToRoomId: Object.assign({}, data.roomIndexToRoomId)
+      joinedCount: data.joinedCount
     };
   }
 
@@ -304,10 +276,10 @@ export class SlidingSync extends TypedEventEmitter {
   setListRanges(key, ranges) {
     var list = this.lists.get(key);
     if (!list) {
-      return Promise.reject(new Error("no list with key " + key));
+      throw new Error("no list with key " + key);
     }
     list.updateListRange(ranges);
-    return this.resend();
+    this.resend();
   }
 
   /**
@@ -328,7 +300,7 @@ export class SlidingSync extends TypedEventEmitter {
       this.lists.set(key, new SlidingList(list));
     }
     this.listModifiedCount += 1;
-    return this.resend();
+    this.resend();
   }
 
   /**
@@ -344,27 +316,21 @@ export class SlidingSync extends TypedEventEmitter {
    * /sync request to resend new subscriptions. If the /sync stream has not started, this will
    * prepare the room subscriptions for when start() is called.
    * @param s - The new desired room subscriptions.
-   * @returns A promise which resolves to the transaction ID when it has been received down sync
-   * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled
-   * immediately after sending, in which case the action will be applied in the subsequent request)
    */
   modifyRoomSubscriptions(s) {
     this.desiredRoomSubscriptions = s;
-    return this.resend();
+    this.resend();
   }
 
   /**
    * Modify which events to retrieve for room subscriptions. Invalidates all room subscriptions
    * such that they will be sent up afresh.
    * @param rs - The new room subscription fields to fetch.
-   * @returns A promise which resolves to the transaction ID when it has been received down sync
-   * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled
-   * immediately after sending, in which case the action will be applied in the subsequent request)
    */
   modifyRoomSubscriptionInfo(rs) {
     this.roomSubscriptionInfo = rs;
     this.confirmedRoomSubscriptions = new Set();
-    return this.resend();
+    this.resend();
   }
 
   /**
@@ -378,19 +344,22 @@ export class SlidingSync extends TypedEventEmitter {
     this.extensions[ext.name()] = ext;
   }
   getExtensionRequest(isInitial) {
-    var ext = {};
-    Object.keys(this.extensions).forEach(extName => {
-      ext[extName] = this.extensions[extName].onRequest(isInitial);
-    });
-    return ext;
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      var ext = {};
+      for (var extName in _this.extensions) {
+        ext[extName] = yield _this.extensions[extName].onRequest(isInitial);
+      }
+      return ext;
+    })();
   }
   onPreExtensionsResponse(ext) {
-    var _this = this;
+    var _this2 = this;
     return _asyncToGenerator(function* () {
       yield Promise.all(Object.keys(ext).map(/*#__PURE__*/function () {
         var _ref = _asyncToGenerator(function* (extName) {
-          if (_this.extensions[extName].when() == ExtensionState.PreProcess) {
-            yield _this.extensions[extName].onResponse(ext[extName]);
+          if (_this2.extensions[extName].when() == ExtensionState.PreProcess) {
+            yield _this2.extensions[extName].onResponse(ext[extName]);
           }
         });
         return function (_x) {
@@ -400,12 +369,12 @@ export class SlidingSync extends TypedEventEmitter {
     })();
   }
   onPostExtensionsResponse(ext) {
-    var _this2 = this;
+    var _this3 = this;
     return _asyncToGenerator(function* () {
       yield Promise.all(Object.keys(ext).map(/*#__PURE__*/function () {
         var _ref2 = _asyncToGenerator(function* (extName) {
-          if (_this2.extensions[extName].when() == ExtensionState.PostProcess) {
-            yield _this2.extensions[extName].onResponse(ext[extName]);
+          if (_this3.extensions[extName].when() == ExtensionState.PostProcess) {
+            yield _this3.extensions[extName].onResponse(ext[extName]);
           }
         });
         return function (_x2) {
@@ -421,7 +390,7 @@ export class SlidingSync extends TypedEventEmitter {
    * @param roomData - The raw sliding sync response JSON.
    */
   invokeRoomDataListeners(roomId, roomData) {
-    var _this3 = this;
+    var _this4 = this;
     return _asyncToGenerator(function* () {
       if (!roomData.required_state) {
         roomData.required_state = [];
@@ -429,7 +398,7 @@ export class SlidingSync extends TypedEventEmitter {
       if (!roomData.timeline) {
         roomData.timeline = [];
       }
-      yield _this3.emitPromised(SlidingSyncEvent.RoomData, roomId, roomData);
+      yield _this4.emitPromised(SlidingSyncEvent.RoomData, roomId, roomData);
     })();
   }
 
@@ -442,202 +411,15 @@ export class SlidingSync extends TypedEventEmitter {
   invokeLifecycleListeners(state, resp, err) {
     this.emit(SlidingSyncEvent.Lifecycle, state, resp, err);
   }
-  shiftRight(listKey, hi, low) {
-    var list = this.lists.get(listKey);
-    if (!list) {
-      return;
-    }
-    //     l   h
-    // 0,1,2,3,4 <- before
-    // 0,1,2,2,3 <- after, hi is deleted and low is duplicated
-    for (var i = hi; i > low; i--) {
-      if (list.isIndexInRange(i)) {
-        list.roomIndexToRoomId[i] = list.roomIndexToRoomId[i - 1];
-      }
-    }
-  }
-  shiftLeft(listKey, hi, low) {
-    var list = this.lists.get(listKey);
-    if (!list) {
-      return;
-    }
-    //     l   h
-    // 0,1,2,3,4 <- before
-    // 0,1,3,4,4 <- after, low is deleted and hi is duplicated
-    for (var i = low; i < hi; i++) {
-      if (list.isIndexInRange(i)) {
-        list.roomIndexToRoomId[i] = list.roomIndexToRoomId[i + 1];
-      }
-    }
-  }
-  removeEntry(listKey, index) {
-    var list = this.lists.get(listKey);
-    if (!list) {
-      return;
-    }
-    // work out the max index
-    var max = -1;
-    for (var n in list.roomIndexToRoomId) {
-      if (Number(n) > max) {
-        max = Number(n);
-      }
-    }
-    if (max < 0 || index > max) {
-      return;
-    }
-    // Everything higher than the gap needs to be shifted left.
-    this.shiftLeft(listKey, max, index);
-    delete list.roomIndexToRoomId[max];
-  }
-  addEntry(listKey, index) {
-    var list = this.lists.get(listKey);
-    if (!list) {
-      return;
-    }
-    // work out the max index
-    var max = -1;
-    for (var n in list.roomIndexToRoomId) {
-      if (Number(n) > max) {
-        max = Number(n);
-      }
-    }
-    if (max < 0 || index > max) {
-      return;
-    }
-    // Everything higher than the gap needs to be shifted right, +1 so we don't delete the highest element
-    this.shiftRight(listKey, max + 1, index);
-  }
-  processListOps(list, listKey) {
-    var gapIndex = -1;
-    var listData = this.lists.get(listKey);
-    if (!listData) {
-      return;
-    }
-    list.ops.forEach(op => {
-      if (!listData) {
-        return;
-      }
-      switch (op.op) {
-        case "DELETE":
-          {
-            logger.debug("DELETE", listKey, op.index, ";");
-            delete listData.roomIndexToRoomId[op.index];
-            if (gapIndex !== -1) {
-              // we already have a DELETE operation to process, so process it.
-              this.removeEntry(listKey, gapIndex);
-            }
-            gapIndex = op.index;
-            break;
-          }
-        case "INSERT":
-          {
-            logger.debug("INSERT", listKey, op.index, op.room_id, ";");
-            if (listData.roomIndexToRoomId[op.index]) {
-              // something is in this space, shift items out of the way
-              if (gapIndex < 0) {
-                // we haven't been told where to shift from, so make way for a new room entry.
-                this.addEntry(listKey, op.index);
-              } else if (gapIndex > op.index) {
-                // the gap is further down the list, shift every element to the right
-                // starting at the gap so we can just shift each element in turn:
-                // [A,B,C,_] gapIndex=3, op.index=0
-                // [A,B,C,C] i=3
-                // [A,B,B,C] i=2
-                // [A,A,B,C] i=1
-                // Terminate. We'll assign into op.index next.
-                this.shiftRight(listKey, gapIndex, op.index);
-              } else if (gapIndex < op.index) {
-                // the gap is further up the list, shift every element to the left
-                // starting at the gap so we can just shift each element in turn
-                this.shiftLeft(listKey, op.index, gapIndex);
-              }
-            }
-            // forget the gap, we don't need it anymore. This is outside the check for
-            // a room being present in this index position because INSERTs always universally
-            // forget the gap, not conditionally based on the presence of a room in the INSERT
-            // position. Without this, DELETE 0; INSERT 0; would do the wrong thing.
-            gapIndex = -1;
-            listData.roomIndexToRoomId[op.index] = op.room_id;
-            break;
-          }
-        case "INVALIDATE":
-          {
-            var startIndex = op.range[0];
-            for (var i = startIndex; i <= op.range[1]; i++) {
-              delete listData.roomIndexToRoomId[i];
-            }
-            logger.debug("INVALIDATE", listKey, op.range[0], op.range[1], ";");
-            break;
-          }
-        case "SYNC":
-          {
-            var _startIndex = op.range[0];
-            for (var _i = _startIndex; _i <= op.range[1]; _i++) {
-              var roomId = op.room_ids[_i - _startIndex];
-              if (!roomId) {
-                break; // we are at the end of list
-              }
-              listData.roomIndexToRoomId[_i] = roomId;
-            }
-            logger.debug("SYNC", listKey, op.range[0], op.range[1], (op.room_ids || []).join(" "), ";");
-            break;
-          }
-      }
-    });
-    if (gapIndex !== -1) {
-      // we already have a DELETE operation to process, so process it
-      // Everything higher than the gap needs to be shifted left.
-      this.removeEntry(listKey, gapIndex);
-    }
-  }
 
   /**
-   * Resend a Sliding Sync request. Used when something has changed in the request. Resolves with
-   * the transaction ID of this request on success. Rejects with the transaction ID of this request
-   * on failure.
+   * Resend a Sliding Sync request. Used when something has changed in the request.
    */
   resend() {
     var _this$abortController;
-    if (this.needsResend && this.txnIdDefers.length > 0) {
-      // we already have a resend queued, so just return the same promise
-      return this.txnIdDefers[this.txnIdDefers.length - 1].promise;
-    }
     this.needsResend = true;
-    this.txnId = this.client.makeTxnId();
-    var d = defer();
-    this.txnIdDefers.push(_objectSpread(_objectSpread({}, d), {}, {
-      txnId: this.txnId
-    }));
     (_this$abortController = this.abortController) === null || _this$abortController === void 0 || _this$abortController.abort();
     this.abortController = new AbortController();
-    return d.promise;
-  }
-  resolveTransactionDefers(txnId) {
-    if (!txnId) {
-      return;
-    }
-    // find the matching index
-    var txnIndex = -1;
-    for (var i = 0; i < this.txnIdDefers.length; i++) {
-      if (this.txnIdDefers[i].txnId === txnId) {
-        txnIndex = i;
-        break;
-      }
-    }
-    if (txnIndex === -1) {
-      // this shouldn't happen; we shouldn't be seeing txn_ids for things we don't know about,
-      // whine about it.
-      logger.warn("resolveTransactionDefers: seen ".concat(txnId, " but it isn't a pending txn, ignoring."));
-      return;
-    }
-    // This list is sorted in time, so if the input txnId ACKs in the middle of this array,
-    // then everything before it that hasn't been ACKed yet never will and we should reject them.
-    for (var _i2 = 0; _i2 < txnIndex; _i2++) {
-      this.txnIdDefers[_i2].reject(this.txnIdDefers[_i2].txnId);
-    }
-    this.txnIdDefers[txnIndex].resolve(txnId);
-    // clear out settled promises, including the one we resolved.
-    this.txnIdDefers = this.txnIdDefers.slice(txnIndex + 1);
   }
 
   /**
@@ -649,7 +431,6 @@ export class SlidingSync extends TypedEventEmitter {
     (_this$abortController2 = this.abortController) === null || _this$abortController2 === void 0 || _this$abortController2.abort();
     // remove all listeners so things can be GC'd
     this.removeAllListeners(SlidingSyncEvent.Lifecycle);
-    this.removeAllListeners(SlidingSyncEvent.List);
     this.removeAllListeners(SlidingSyncEvent.RoomData);
   }
 
@@ -657,90 +438,69 @@ export class SlidingSync extends TypedEventEmitter {
    * Re-setup this connection e.g in the event of an expired session.
    */
   resetup() {
-    var _this$abortController3;
     logger.warn("SlidingSync: resetting connection info");
-    // any pending txn ID defers will be forgotten already by the server, so clear them out
-    this.txnIdDefers.forEach(d => {
-      d.reject(d.txnId);
-    });
-    this.txnIdDefers = [];
     // resend sticky params and de-confirm all subscriptions
     this.lists.forEach(l => {
       l.setModified(true);
     });
     this.confirmedRoomSubscriptions = new Set(); // leave desired ones alone though!
     // reset the connection as we might be wedged
-    this.needsResend = true;
-    (_this$abortController3 = this.abortController) === null || _this$abortController3 === void 0 || _this$abortController3.abort();
-    this.abortController = new AbortController();
+    this.resend();
   }
 
   /**
    * Start syncing with the server. Blocks until stopped.
    */
   start() {
-    var _this4 = this;
+    var _this5 = this;
     return _asyncToGenerator(function* () {
-      _this4.abortController = new AbortController();
+      _this5.abortController = new AbortController();
       var currentPos;
       var _loop = function* _loop() {
-          _this4.needsResend = false;
-          var doNotUpdateList = false;
+          _this5.needsResend = false;
           var resp;
           try {
             var _resp$lists, _resp$rooms, _resp$extensions;
-            var listModifiedCount = _this4.listModifiedCount;
             var reqLists = {};
-            _this4.lists.forEach((l, key) => {
-              reqLists[key] = l.getList(false);
+            _this5.lists.forEach((l, key) => {
+              reqLists[key] = l.getList(true);
             });
             var reqBody = {
               lists: reqLists,
               pos: currentPos,
-              timeout: _this4.timeoutMS,
-              clientTimeout: _this4.timeoutMS + BUFFER_PERIOD_MS,
-              extensions: _this4.getExtensionRequest(currentPos === undefined)
+              timeout: _this5.timeoutMS,
+              clientTimeout: _this5.timeoutMS + BUFFER_PERIOD_MS,
+              extensions: yield _this5.getExtensionRequest(currentPos === undefined)
             };
             // check if we are (un)subscribing to a room and modify request this one time for it
-            var newSubscriptions = difference(_this4.desiredRoomSubscriptions, _this4.confirmedRoomSubscriptions);
-            var unsubscriptions = difference(_this4.confirmedRoomSubscriptions, _this4.desiredRoomSubscriptions);
+            var newSubscriptions = difference(_this5.desiredRoomSubscriptions, _this5.confirmedRoomSubscriptions);
+            var unsubscriptions = difference(_this5.confirmedRoomSubscriptions, _this5.desiredRoomSubscriptions);
             if (unsubscriptions.size > 0) {
               reqBody.unsubscribe_rooms = Array.from(unsubscriptions);
             }
             if (newSubscriptions.size > 0) {
               reqBody.room_subscriptions = {};
               for (var roomId of newSubscriptions) {
-                var customSubName = _this4.roomIdToCustomSubscription.get(roomId);
-                var sub = _this4.roomSubscriptionInfo;
-                if (customSubName && _this4.customSubscriptions.has(customSubName)) {
-                  sub = _this4.customSubscriptions.get(customSubName);
+                var customSubName = _this5.roomIdToCustomSubscription.get(roomId);
+                var sub = _this5.roomSubscriptionInfo;
+                if (customSubName && _this5.customSubscriptions.has(customSubName)) {
+                  sub = _this5.customSubscriptions.get(customSubName);
                 }
                 reqBody.room_subscriptions[roomId] = sub;
               }
             }
-            if (_this4.txnId) {
-              reqBody.txn_id = _this4.txnId;
-              _this4.txnId = null;
-            }
-            _this4.pendingReq = _this4.client.slidingSync(reqBody, _this4.proxyBaseUrl, _this4.abortController.signal);
-            resp = yield _this4.pendingReq;
+            _this5.pendingReq = _this5.client.slidingSync(reqBody, _this5.proxyBaseUrl, _this5.abortController.signal);
+            resp = yield _this5.pendingReq;
             currentPos = resp.pos;
             // update what we think we're subscribed to.
             for (var _roomId of newSubscriptions) {
-              _this4.confirmedRoomSubscriptions.add(_roomId);
+              _this5.confirmedRoomSubscriptions.add(_roomId);
             }
             for (var _roomId2 of unsubscriptions) {
-              _this4.confirmedRoomSubscriptions.delete(_roomId2);
-            }
-            if (listModifiedCount !== _this4.listModifiedCount) {
-              // the lists have been modified whilst we were waiting for 'await' to return, but the abort()
-              // call did nothing. It is NOT SAFE to modify the list array now. We'll process the response but
-              // not update list pointers.
-              logger.debug("list modified during await call, not updating list");
-              doNotUpdateList = true;
+              _this5.confirmedRoomSubscriptions.delete(_roomId2);
             }
             // mark all these lists as having been sent as sticky so we don't keep sending sticky params
-            _this4.lists.forEach(l => {
+            _this5.lists.forEach(l => {
               l.setModified(false);
             });
             // set default empty values so we don't need to null check
@@ -748,25 +508,25 @@ export class SlidingSync extends TypedEventEmitter {
             resp.rooms = (_resp$rooms = resp.rooms) !== null && _resp$rooms !== void 0 ? _resp$rooms : {};
             resp.extensions = (_resp$extensions = resp.extensions) !== null && _resp$extensions !== void 0 ? _resp$extensions : {};
             Object.keys(resp.lists).forEach(key => {
-              var list = _this4.lists.get(key);
+              var list = _this5.lists.get(key);
               if (!list || !resp) {
                 return;
               }
               list.joinedCount = resp.lists[key].count;
             });
-            _this4.invokeLifecycleListeners(SlidingSyncState.RequestFinished, resp);
+            _this5.invokeLifecycleListeners(SlidingSyncState.RequestFinished, resp);
           } catch (err) {
             if (err.httpStatus) {
-              _this4.invokeLifecycleListeners(SlidingSyncState.RequestFinished, null, err);
+              _this5.invokeLifecycleListeners(SlidingSyncState.RequestFinished, null, err);
               if (err.httpStatus === 400) {
                 // session probably expired TODO: assign an errcode
                 // so drop state and re-request
-                _this4.resetup();
+                _this5.resetup();
                 currentPos = undefined;
                 yield sleep(50); // in case the 400 was for something else; don't tightloop
                 return 0; // continue
               } // else fallthrough to generic error handling
-            } else if (_this4.needsResend || err.name === "AbortError") {
+            } else if (_this5.needsResend || err.name === "AbortError") {
               return 0; // continue
               // don't sleep as we caused this error by abort()ing the request.
             }
@@ -776,34 +536,15 @@ export class SlidingSync extends TypedEventEmitter {
           if (!resp) {
             return 0; // continue
           }
-          yield _this4.onPreExtensionsResponse(resp.extensions);
+          yield _this5.onPreExtensionsResponse(resp.extensions);
           for (var _roomId3 in resp.rooms) {
-            yield _this4.invokeRoomDataListeners(_roomId3, resp.rooms[_roomId3]);
+            yield _this5.invokeRoomDataListeners(_roomId3, resp.rooms[_roomId3]);
           }
-          var listKeysWithUpdates = new Set();
-          if (!doNotUpdateList) {
-            for (var [key, list] of Object.entries(resp.lists)) {
-              var _list$ops;
-              list.ops = (_list$ops = list.ops) !== null && _list$ops !== void 0 ? _list$ops : [];
-              if (list.ops.length > 0) {
-                listKeysWithUpdates.add(key);
-              }
-              _this4.processListOps(list, key);
-            }
-          }
-          _this4.invokeLifecycleListeners(SlidingSyncState.Complete, resp);
-          yield _this4.onPostExtensionsResponse(resp.extensions);
-          listKeysWithUpdates.forEach(listKey => {
-            var list = _this4.lists.get(listKey);
-            if (!list) {
-              return;
-            }
-            _this4.emit(SlidingSyncEvent.List, listKey, list.joinedCount, Object.assign({}, list.roomIndexToRoomId));
-          });
-          _this4.resolveTransactionDefers(resp.txn_id);
+          _this5.invokeLifecycleListeners(SlidingSyncState.Complete, resp);
+          yield _this5.onPostExtensionsResponse(resp.extensions);
         },
         _ret;
-      while (!_this4.terminated) {
+      while (!_this5.terminated) {
         _ret = yield* _loop();
         if (_ret === 0) continue;
       }