@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/sliding-sync.js

@@ -0,0 +1,817 @@
+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.
+
+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 { logger } from "./logger.js";
+import { TypedEventEmitter } from "./models/typed-event-emitter.js";
+import { sleep, defer } 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
+// to determine the max time we're willing to wait.
+var BUFFER_PERIOD_MS = 10 * 1000;
+export var MSC3575_WILDCARD = "*";
+export var MSC3575_STATE_KEY_ME = "$ME";
+export var MSC3575_STATE_KEY_LAZY = "$LAZY";
+
+/**
+ * Represents a subscription to a room or set of rooms. Controls which events are returned.
+ */
+
+/**
+ * Controls which rooms are returned in a given list.
+ */
+
+/**
+ * Represents a list subscription.
+ */
+
+/**
+ * A complete Sliding Sync request.
+ */
+
+/**
+ * A complete Sliding Sync response
+ */
+
+export var SlidingSyncState = /*#__PURE__*/function (SlidingSyncState) {
+  SlidingSyncState["RequestFinished"] = "FINISHED";
+  SlidingSyncState["Complete"] = "COMPLETE";
+  return SlidingSyncState;
+}({});
+
+/**
+ * Internal Class. SlidingList represents a single list in sliding sync. The list can have filters,
+ * multiple sliding windows, and maintains the index-\>room_id mapping.
+ */
+class SlidingList {
+  /**
+   * Construct a new sliding list.
+   * @param list - The range, sort and filter values to use for this list.
+   */
+  constructor(list) {
+    _defineProperty(this, "list", void 0);
+    _defineProperty(this, "isModified", void 0);
+    // returned data
+    _defineProperty(this, "roomIndexToRoomId", {});
+    _defineProperty(this, "joinedCount", 0);
+    this.replaceList(list);
+  }
+
+  /**
+   * Mark this list as modified or not. Modified lists will return sticky params with calls to getList.
+   * This is useful for the first time the list is sent, or if the list has changed in some way.
+   * @param modified - True to mark this list as modified so all sticky parameters will be re-sent.
+   */
+  setModified(modified) {
+    this.isModified = modified;
+  }
+
+  /**
+   * Update the list range for this list. Does not affect modified status as list ranges are non-sticky.
+   * @param newRanges - The new ranges for the list
+   */
+  updateListRange(newRanges) {
+    this.list.ranges = JSON.parse(JSON.stringify(newRanges));
+  }
+
+  /**
+   * Replace list parameters. All fields will be replaced with the new list parameters.
+   * @param list - The new list parameters
+   */
+  replaceList(list) {
+    list.filters = list.filters || {};
+    list.ranges = list.ranges || [];
+    this.list = JSON.parse(JSON.stringify(list));
+    this.isModified = true;
+
+    // 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;
+  }
+
+  /**
+   * Return a copy of the list suitable for a request body.
+   * @param forceIncludeAllParams - True to forcibly include all params even if the list
+   * hasn't been modified. Callers may want to do this if they are modifying the list prior to calling
+   * updateList.
+   */
+  getList(forceIncludeAllParams) {
+    var list = {
+      ranges: JSON.parse(JSON.stringify(this.list.ranges))
+    };
+    if (this.isModified || forceIncludeAllParams) {
+      list = JSON.parse(JSON.stringify(this.list));
+    }
+    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;
+  }
+}
+
+/**
+ * When onResponse extensions should be invoked: before or after processing the main response.
+ */
+export var ExtensionState = /*#__PURE__*/function (ExtensionState) {
+  ExtensionState["PreProcess"] = "ExtState.PreProcess";
+  ExtensionState["PostProcess"] = "ExtState.PostProcess";
+  return ExtensionState;
+}({});
+
+/**
+ * An interface that must be satisfied to register extensions
+ */
+
+/**
+ * Events which can be fired by the SlidingSync class. These are designed to provide different levels
+ * 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;
+}({});
+/**
+ * SlidingSync is a high-level data structure which controls the majority of sliding sync.
+ * It has no hooks into JS SDK except for needing a MatrixClient to perform the HTTP request.
+ * This means this class (and everything it uses) can be used in isolation from JS SDK if needed.
+ * To hook this up with the JS SDK, you need to use SlidingSyncSdk.
+ */
+export class SlidingSync extends TypedEventEmitter {
+  /**
+   * Create a new sliding sync instance
+   * @param proxyBaseUrl - The base URL of the sliding sync proxy
+   * @param lists - The lists to use for sliding sync.
+   * @param roomSubscriptionInfo - The params to use for room subscriptions.
+   * @param client - The client to use for /sync calls.
+   * @param timeoutMS - The number of milliseconds to wait for a response.
+   */
+  constructor(proxyBaseUrl, lists, roomSubscriptionInfo, client, timeoutMS) {
+    super();
+    this.proxyBaseUrl = proxyBaseUrl;
+    this.roomSubscriptionInfo = roomSubscriptionInfo;
+    this.client = client;
+    this.timeoutMS = timeoutMS;
+    _defineProperty(this, "lists", void 0);
+    _defineProperty(this, "listModifiedCount", 0);
+    _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());
+    // the *desired* room subscriptions
+    _defineProperty(this, "confirmedRoomSubscriptions", new Set());
+    // map of custom subscription name to the subscription
+    _defineProperty(this, "customSubscriptions", new Map());
+    // map of room ID to custom subscription name
+    _defineProperty(this, "roomIdToCustomSubscription", new Map());
+    _defineProperty(this, "pendingReq", void 0);
+    _defineProperty(this, "abortController", void 0);
+    this.lists = new Map();
+    lists.forEach((list, key) => {
+      this.lists.set(key, new SlidingList(list));
+    });
+  }
+
+  /**
+   * Add a custom room subscription, referred to by an arbitrary name. If a subscription with this
+   * name already exists, it is replaced. No requests are sent by calling this method.
+   * @param name - The name of the subscription. Only used to reference this subscription in
+   * useCustomSubscription.
+   * @param sub - The subscription information.
+   */
+  addCustomSubscription(name, sub) {
+    if (this.customSubscriptions.has(name)) {
+      logger.warn("addCustomSubscription: ".concat(name, " already exists as a custom subscription, ignoring."));
+      return;
+    }
+    this.customSubscriptions.set(name, sub);
+  }
+
+  /**
+   * Use a custom subscription previously added via addCustomSubscription. No requests are sent
+   * by calling this method. Use modifyRoomSubscriptions to resend subscription information.
+   * @param roomId - The room to use the subscription in.
+   * @param name - The name of the subscription. If this name is unknown, the default subscription
+   * will be used.
+   */
+  useCustomSubscription(roomId, name) {
+    // We already know about this custom subscription, as it is immutable,
+    // we don't need to unconfirm the subscription.
+    if (this.roomIdToCustomSubscription.get(roomId) === name) {
+      return;
+    }
+    this.roomIdToCustomSubscription.set(roomId, name);
+    // unconfirm this subscription so a resend() will send it up afresh.
+    this.confirmedRoomSubscriptions.delete(roomId);
+  }
+
+  /**
+   * Get the room index data for a list.
+   * @param key - The list key
+   * @returns The list data which contains the rooms in this list
+   */
+  getListData(key) {
+    var data = this.lists.get(key);
+    if (!data) {
+      return null;
+    }
+    return {
+      joinedCount: data.joinedCount,
+      roomIndexToRoomId: Object.assign({}, data.roomIndexToRoomId)
+    };
+  }
+
+  /**
+   * Get the full request list parameters for a list index. This function is provided for callers to use
+   * in conjunction with setList to update fields on an existing list.
+   * @param key - The list key to get the params for.
+   * @returns A copy of the list params or undefined.
+   */
+  getListParams(key) {
+    var params = this.lists.get(key);
+    if (!params) {
+      return null;
+    }
+    return params.getList(true);
+  }
+
+  /**
+   * Set new ranges for an existing list. Calling this function when _only_ the ranges have changed
+   * is more efficient than calling setList(index,list) as this function won't resend sticky params,
+   * whereas setList always will.
+   * @param key - The list key to modify
+   * @param ranges - The new ranges to apply.
+   * @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)
+   */
+  setListRanges(key, ranges) {
+    var list = this.lists.get(key);
+    if (!list) {
+      return Promise.reject(new Error("no list with key " + key));
+    }
+    list.updateListRange(ranges);
+    return this.resend();
+  }
+
+  /**
+   * Add or replace a list. Calling this function will interrupt the /sync request to resend new
+   * lists.
+   * @param key - The key to modify
+   * @param list - The new list parameters.
+   * @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)
+   */
+  setList(key, list) {
+    var existingList = this.lists.get(key);
+    if (existingList) {
+      existingList.replaceList(list);
+      this.lists.set(key, existingList);
+    } else {
+      this.lists.set(key, new SlidingList(list));
+    }
+    this.listModifiedCount += 1;
+    return this.resend();
+  }
+
+  /**
+   * Get the room subscriptions for the sync API.
+   * @returns A copy of the desired room subscriptions.
+   */
+  getRoomSubscriptions() {
+    return new Set(Array.from(this.desiredRoomSubscriptions));
+  }
+
+  /**
+   * Modify the room subscriptions for the sync API. Calling this function will interrupt the
+   * /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();
+  }
+
+  /**
+   * 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();
+  }
+
+  /**
+   * Register an extension to send with the /sync request.
+   * @param ext - The extension to register.
+   */
+  registerExtension(ext) {
+    if (this.extensions[ext.name()]) {
+      throw new Error("registerExtension: ".concat(ext.name(), " already exists as an extension"));
+    }
+    this.extensions[ext.name()] = ext;
+  }
+  getExtensionRequest(isInitial) {
+    var ext = {};
+    Object.keys(this.extensions).forEach(extName => {
+      ext[extName] = this.extensions[extName].onRequest(isInitial);
+    });
+    return ext;
+  }
+  onPreExtensionsResponse(ext) {
+    var _this = 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]);
+          }
+        });
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }()));
+    })();
+  }
+  onPostExtensionsResponse(ext) {
+    var _this2 = 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]);
+          }
+        });
+        return function (_x2) {
+          return _ref2.apply(this, arguments);
+        };
+      }()));
+    })();
+  }
+
+  /**
+   * Invoke all attached room data listeners.
+   * @param roomId - The room which received some data.
+   * @param roomData - The raw sliding sync response JSON.
+   */
+  invokeRoomDataListeners(roomId, roomData) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      if (!roomData.required_state) {
+        roomData.required_state = [];
+      }
+      if (!roomData.timeline) {
+        roomData.timeline = [];
+      }
+      yield _this3.emitPromised(SlidingSyncEvent.RoomData, roomId, roomData);
+    })();
+  }
+
+  /**
+   * Invoke all attached lifecycle listeners.
+   * @param state - The Lifecycle state
+   * @param resp - The raw sync response JSON
+   * @param err - Any error that occurred when making the request e.g. network errors.
+   */
+  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() {
+    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);
+  }
+
+  /**
+   * Stop syncing with the server.
+   */
+  stop() {
+    var _this$abortController2;
+    this.terminated = true;
+    (_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);
+  }
+
+  /**
+   * 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();
+  }
+
+  /**
+   * Start syncing with the server. Blocks until stopped.
+   */
+  start() {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      _this4.abortController = new AbortController();
+      var currentPos;
+      var _loop = function* _loop() {
+          _this4.needsResend = false;
+          var doNotUpdateList = false;
+          var resp;
+          try {
+            var listModifiedCount = _this4.listModifiedCount;
+            var reqLists = {};
+            _this4.lists.forEach((l, key) => {
+              reqLists[key] = l.getList(false);
+            });
+            var reqBody = {
+              lists: reqLists,
+              pos: currentPos,
+              timeout: _this4.timeoutMS,
+              clientTimeout: _this4.timeoutMS + BUFFER_PERIOD_MS,
+              extensions: _this4.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);
+            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);
+                }
+                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;
+            currentPos = resp.pos;
+            // update what we think we're subscribed to.
+            for (var _roomId of newSubscriptions) {
+              _this4.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;
+            }
+            // mark all these lists as having been sent as sticky so we don't keep sending sticky params
+            _this4.lists.forEach(l => {
+              l.setModified(false);
+            });
+            // set default empty values so we don't need to null check
+            resp.lists = resp.lists || {};
+            resp.rooms = resp.rooms || {};
+            resp.extensions = resp.extensions || {};
+            Object.keys(resp.lists).forEach(key => {
+              var list = _this4.lists.get(key);
+              if (!list || !resp) {
+                return;
+              }
+              list.joinedCount = resp.lists[key].count;
+            });
+            _this4.invokeLifecycleListeners(SlidingSyncState.RequestFinished, resp);
+          } catch (err) {
+            if (err.httpStatus) {
+              _this4.invokeLifecycleListeners(SlidingSyncState.RequestFinished, null, err);
+              if (err.httpStatus === 400) {
+                // session probably expired TODO: assign an errcode
+                // so drop state and re-request
+                _this4.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") {
+              return 0; // continue
+              // don't sleep as we caused this error by abort()ing the request.
+            }
+            logger.error(err);
+            yield sleep(5000);
+          }
+          if (!resp) {
+            return 0; // continue
+          }
+          yield _this4.onPreExtensionsResponse(resp.extensions);
+          for (var _roomId3 in resp.rooms) {
+            yield _this4.invokeRoomDataListeners(_roomId3, resp.rooms[_roomId3]);
+          }
+          var listKeysWithUpdates = new Set();
+          if (!doNotUpdateList) {
+            for (var [key, list] of Object.entries(resp.lists)) {
+              list.ops = 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);
+        },
+        _ret;
+      while (!_this4.terminated) {
+        _ret = yield* _loop();
+        if (_ret === 0) continue;
+      }
+    })();
+  }
+}
+var difference = (setA, setB) => {
+  var diff = new Set(setA);
+  for (var elem of setB) {
+    diff.delete(elem);
+  }
+  return diff;
+};
+//# sourceMappingURL=sliding-sync.js.map