@openclaw/matrix 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/matrix-js-sdk/lib/store/indexeddb-local-backend.js

@@ -1,5 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /*
 Copyright 2017 - 2021 The Matrix.org Foundation C.I.C.
@@ -21,7 +19,7 @@ import { SyncAccumulator } from "../sync-accumulator.js";
 import { deepCopy, promiseTry } from "../utils.js";
 import { exists as idbExists } from "../indexeddb-helpers.js";
 import { logger } from "../logger.js";
-var DB_MIGRATIONS = [db => {
+const DB_MIGRATIONS = [db => {
   // Make user store, clobber based on user ID. (userId property of User objects)
   db.createObjectStore("users", {
     keyPath: ["userId"]
@@ -38,7 +36,7 @@ var DB_MIGRATIONS = [db => {
     keyPath: ["clobber"]
   });
 }, db => {
-  var oobMembersStore = db.createObjectStore("oob_membership_events", {
+  const oobMembersStore = db.createObjectStore("oob_membership_events", {
     keyPath: ["room_id", "state_key"]
   });
   oobMembersStore.createIndex("room", "room_id");
@@ -57,7 +55,7 @@ var DB_MIGRATIONS = [db => {
 }
 // Expand as needed.
 ];
-var VERSION = DB_MIGRATIONS.length;
+const VERSION = DB_MIGRATIONS.length;
 
 /**
  * Helper method to collect results from a Cursor and promiseify it.
@@ -71,17 +69,17 @@ var VERSION = DB_MIGRATIONS.length;
  * @throws If there was an error completing the query.
  */
 function selectQuery(store, keyRange, resultMapper) {
-  var query = store.openCursor(keyRange);
+  const query = store.openCursor(keyRange);
   return new Promise((resolve, reject) => {
-    var results = [];
+    const results = [];
     query.onerror = () => {
-      reject(new Error("selectQuery failed for ".concat(store.name), {
+      reject(new Error(`selectQuery failed for ${store.name}`, {
         cause: query.error
       }));
     };
     // collect results
     query.onsuccess = () => {
-      var cursor = query.result;
+      const cursor = query.result;
       if (!cursor) {
         resolve(results);
         return; // end of results
@@ -135,10 +133,13 @@ export class LocalIndexedDBStoreBackend {
    * @param dbName - Optional database name. The same name must be used
    * to open the same database.
    */
-  constructor(indexedDB) {
-    var dbName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "default";
+  constructor(indexedDB, dbName = "default") {
+    _defineProperty(this, "dbName", void 0);
+    _defineProperty(this, "syncAccumulator", void 0);
+    _defineProperty(this, "db", void 0);
     _defineProperty(this, "disconnected", true);
     _defineProperty(this, "_isNewlyCreated", false);
+    _defineProperty(this, "syncToDatabasePromise", void 0);
     _defineProperty(this, "pendingUserPresenceData", []);
     this.indexedDB = indexedDB;
     this.dbName = "matrix-js-sdk:" + dbName;
@@ -151,18 +152,17 @@ export class LocalIndexedDBStoreBackend {
    * @returns Promise which resolves if successfully connected.
    */
   connect(onClose) {
-    var _this = this;
     if (!this.disconnected) {
-      logger.log("LocalIndexedDBStoreBackend.connect: already connected or connecting");
+      logger.log(`LocalIndexedDBStoreBackend.connect: already connected or connecting`);
       return Promise.resolve();
     }
     this.disconnected = false;
-    logger.log("LocalIndexedDBStoreBackend.connect: connecting...");
-    var req = this.indexedDB.open(this.dbName, VERSION);
+    logger.log(`LocalIndexedDBStoreBackend.connect: connecting...`);
+    const req = this.indexedDB.open(this.dbName, VERSION);
     req.onupgradeneeded = ev => {
-      var db = req.result;
-      var oldVersion = ev.oldVersion;
-      logger.log("LocalIndexedDBStoreBackend.connect: upgrading from ".concat(oldVersion));
+      const db = req.result;
+      const oldVersion = ev.oldVersion;
+      logger.log(`LocalIndexedDBStoreBackend.connect: upgrading from ${oldVersion}`);
       if (oldVersion < 1) {
         // The database did not previously exist
         this._isNewlyCreated = true;
@@ -172,28 +172,27 @@ export class LocalIndexedDBStoreBackend {
       });
     };
     req.onblocked = () => {
-      logger.log("can't yet open LocalIndexedDBStoreBackend because it is open elsewhere");
+      logger.log(`can't yet open LocalIndexedDBStoreBackend because it is open elsewhere`);
     };
-    logger.log("LocalIndexedDBStoreBackend.connect: awaiting connection...");
-    return reqAsEventPromise(req).then(/*#__PURE__*/_asyncToGenerator(function* () {
-      logger.log("LocalIndexedDBStoreBackend.connect: connected");
-      _this.db = req.result;
+    logger.log(`LocalIndexedDBStoreBackend.connect: awaiting connection...`);
+    return reqAsEventPromise(req).then(async () => {
+      logger.log(`LocalIndexedDBStoreBackend.connect: connected`);
+      this.db = req.result;
 
       // add a poorly-named listener for when deleteDatabase is called
       // so we can close our db connections.
-      _this.db.onversionchange = () => {
-        var _this$db;
-        (_this$db = _this.db) === null || _this$db === void 0 || _this$db.close(); // this does not call onclose
-        _this.disconnected = true;
-        _this.db = undefined;
+      this.db.onversionchange = () => {
+        this.db?.close(); // this does not call onclose
+        this.disconnected = true;
+        this.db = undefined;
       };
-      _this.db.onclose = () => {
-        _this.disconnected = true;
-        _this.db = undefined;
-        onClose === null || onClose === void 0 || onClose();
+      this.db.onclose = () => {
+        this.disconnected = true;
+        this.db = undefined;
+        onClose?.();
       };
-      yield _this.init();
-    }));
+      await this.init();
+    });
   }
 
   /** @returns whether or not the database was newly created in this session. */
@@ -206,11 +205,8 @@ export class LocalIndexedDBStoreBackend {
    * @returns Promise which resolves on success
    */
   init() {
-    return Promise.all([this.loadAccountData(), this.loadSyncData()]).then(_ref2 => {
-      var _ref3 = _slicedToArray(_ref2, 2),
-        accountData = _ref3[0],
-        syncData = _ref3[1];
-      logger.log("LocalIndexedDBStoreBackend: loaded initial data");
+    return Promise.all([this.loadAccountData(), this.loadSyncData()]).then(([accountData, syncData]) => {
+      logger.log(`LocalIndexedDBStoreBackend: loaded initial data`);
       this.syncAccumulator.accumulate({
         next_batch: syncData.nextBatch,
         rooms: syncData.roomsData,
@@ -229,20 +225,20 @@ export class LocalIndexedDBStoreBackend {
    */
   getOutOfBandMembers(roomId) {
     return new Promise((resolve, reject) => {
-      var tx = this.db.transaction(["oob_membership_events"], "readonly");
-      var store = tx.objectStore("oob_membership_events");
-      var roomIndex = store.index("room");
-      var range = IDBKeyRange.only(roomId);
-      var request = roomIndex.openCursor(range);
-      var membershipEvents = [];
+      const tx = this.db.transaction(["oob_membership_events"], "readonly");
+      const store = tx.objectStore("oob_membership_events");
+      const roomIndex = store.index("room");
+      const range = IDBKeyRange.only(roomId);
+      const request = roomIndex.openCursor(range);
+      const membershipEvents = [];
       // did we encounter the oob_written marker object
       // amongst the results? That means OOB member
       // loading already happened for this room
       // but there were no members to persist as they
       // were all known already
-      var oobWritten = false;
+      let oobWritten = false;
       request.onsuccess = () => {
-        var cursor = request.result;
+        const cursor = request.result;
         if (!cursor) {
           // Unknown room
           if (!membershipEvents.length && !oobWritten) {
@@ -250,7 +246,7 @@ export class LocalIndexedDBStoreBackend {
           }
           return resolve(membershipEvents);
         }
-        var record = cursor.value;
+        const record = cursor.value;
         if (record.oob_written) {
           oobWritten = true;
         } else {
@@ -262,7 +258,7 @@ export class LocalIndexedDBStoreBackend {
         reject(err);
       };
     }).then(events => {
-      logger.log("LL: got ".concat(events === null || events === void 0 ? void 0 : events.length, " membershipEvents from storage for room ").concat(roomId, " ..."));
+      logger.log(`LL: got ${events?.length} membershipEvents from storage for room ${roomId} ...`);
       return events;
     });
   }
@@ -273,55 +269,46 @@ export class LocalIndexedDBStoreBackend {
    * marked as fetched, and getOutOfBandMembers will return an empty array instead of null
    * @param membershipEvents - the membership events to store
    */
-  setOutOfBandMembers(roomId, membershipEvents) {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      logger.log("LL: backend about to store ".concat(membershipEvents.length) + " members for ".concat(roomId));
-      var tx = _this2.db.transaction(["oob_membership_events"], "readwrite");
-      var store = tx.objectStore("oob_membership_events");
-      membershipEvents.forEach(e => {
-        store.put(e);
-      });
-      // aside from all the events, we also write a marker object to the store
-      // to mark the fact that OOB members have been written for this room.
-      // It's possible that 0 members need to be written as all where previously know
-      // but we still need to know whether to return null or [] from getOutOfBandMembers
-      // where null means out of band members haven't been stored yet for this room
-      var markerObject = {
-        room_id: roomId,
-        oob_written: true,
-        state_key: 0
-      };
-      store.put(markerObject);
-      yield txnAsPromise(tx);
-      logger.log("LL: backend done storing for ".concat(roomId, "!"));
-    })();
+  async setOutOfBandMembers(roomId, membershipEvents) {
+    logger.log(`LL: backend about to store ${membershipEvents.length}` + ` members for ${roomId}`);
+    const tx = this.db.transaction(["oob_membership_events"], "readwrite");
+    const store = tx.objectStore("oob_membership_events");
+    membershipEvents.forEach(e => {
+      store.put(e);
+    });
+    // aside from all the events, we also write a marker object to the store
+    // to mark the fact that OOB members have been written for this room.
+    // It's possible that 0 members need to be written as all where previously know
+    // but we still need to know whether to return null or [] from getOutOfBandMembers
+    // where null means out of band members haven't been stored yet for this room
+    const markerObject = {
+      room_id: roomId,
+      oob_written: true,
+      state_key: 0
+    };
+    store.put(markerObject);
+    await txnAsPromise(tx);
+    logger.log(`LL: backend done storing for ${roomId}!`);
   }
-  clearOutOfBandMembers(roomId) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      // the approach to delete all members for a room
-      // is to get the min and max state key from the index
-      // for that room, and then delete between those
-      // keys in the store.
-      // this should be way faster than deleting every member
-      // individually for a large room.
-      var readTx = _this3.db.transaction(["oob_membership_events"], "readonly");
-      var store = readTx.objectStore("oob_membership_events");
-      var roomIndex = store.index("room");
-      var roomRange = IDBKeyRange.only(roomId);
-      var minStateKeyProm = reqAsCursorPromise(roomIndex.openKeyCursor(roomRange, "next")).then(cursor => (cursor === null || cursor === void 0 ? void 0 : cursor.primaryKey)[1]);
-      var maxStateKeyProm = reqAsCursorPromise(roomIndex.openKeyCursor(roomRange, "prev")).then(cursor => (cursor === null || cursor === void 0 ? void 0 : cursor.primaryKey)[1]);
-      var _yield$Promise$all = yield Promise.all([minStateKeyProm, maxStateKeyProm]),
-        _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2),
-        minStateKey = _yield$Promise$all2[0],
-        maxStateKey = _yield$Promise$all2[1];
-      var writeTx = _this3.db.transaction(["oob_membership_events"], "readwrite");
-      var writeStore = writeTx.objectStore("oob_membership_events");
-      var membersKeyRange = IDBKeyRange.bound([roomId, minStateKey], [roomId, maxStateKey]);
-      logger.log("LL: Deleting all users + marker in storage for room ".concat(roomId, ", with key range:"), [roomId, minStateKey], [roomId, maxStateKey]);
-      yield reqAsPromise(writeStore.delete(membersKeyRange));
-    })();
+  async clearOutOfBandMembers(roomId) {
+    // the approach to delete all members for a room
+    // is to get the min and max state key from the index
+    // for that room, and then delete between those
+    // keys in the store.
+    // this should be way faster than deleting every member
+    // individually for a large room.
+    const readTx = this.db.transaction(["oob_membership_events"], "readonly");
+    const store = readTx.objectStore("oob_membership_events");
+    const roomIndex = store.index("room");
+    const roomRange = IDBKeyRange.only(roomId);
+    const minStateKeyProm = reqAsCursorPromise(roomIndex.openKeyCursor(roomRange, "next")).then(cursor => cursor?.primaryKey?.[1]);
+    const maxStateKeyProm = reqAsCursorPromise(roomIndex.openKeyCursor(roomRange, "prev")).then(cursor => cursor?.primaryKey?.[1]);
+    const [minStateKey, maxStateKey] = await Promise.all([minStateKeyProm, maxStateKeyProm]);
+    const writeTx = this.db.transaction(["oob_membership_events"], "readwrite");
+    const writeStore = writeTx.objectStore("oob_membership_events");
+    const membersKeyRange = IDBKeyRange.bound([roomId, minStateKey], [roomId, maxStateKey]);
+    logger.log(`LL: Deleting all users + marker in storage for room ${roomId}, with key range:`, [roomId, minStateKey], [roomId, maxStateKey]);
+    await reqAsPromise(writeStore.delete(membersKeyRange));
   }
 
   /**
@@ -331,25 +318,23 @@ export class LocalIndexedDBStoreBackend {
    */
   clearDatabase() {
     return new Promise(resolve => {
-      var _this$db2;
-      logger.log("Removing indexeddb instance: ".concat(this.dbName));
+      logger.log(`Removing indexeddb instance: ${this.dbName}`);
 
       // Close the database first to avoid firing unexpected close events
-      (_this$db2 = this.db) === null || _this$db2 === void 0 || _this$db2.close();
-      var req = this.indexedDB.deleteDatabase(this.dbName);
+      this.db?.close();
+      const req = this.indexedDB.deleteDatabase(this.dbName);
       req.onblocked = () => {
-        logger.log("can't yet delete indexeddb ".concat(this.dbName, " because it is open elsewhere"));
+        logger.log(`can't yet delete indexeddb ${this.dbName} because it is open elsewhere`);
       };
       req.onerror = () => {
-        var _req$error;
         // in firefox, with indexedDB disabled, this fails with a
         // DOMError. We treat this as non-fatal, so that we can still
         // use the app.
-        logger.warn("unable to delete js-sdk store indexeddb: ".concat((_req$error = req.error) === null || _req$error === void 0 ? void 0 : _req$error.name));
+        logger.warn(`unable to delete js-sdk store indexeddb: ${req.error?.name}`);
         resolve();
       };
       req.onsuccess = () => {
-        logger.log("Removed indexeddb instance: ".concat(this.dbName));
+        logger.log(`Removed indexeddb instance: ${this.dbName}`);
         resolve();
       };
     });
@@ -364,9 +349,8 @@ export class LocalIndexedDBStoreBackend {
    * client state to where it was at the last save, or null if there
    * is no saved sync data.
    */
-  getSavedSync() {
-    var copy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    var data = this.syncAccumulator.getJSON();
+  getSavedSync(copy = true) {
+    const data = this.syncAccumulator.getJSON();
     if (!data.nextBatch) return Promise.resolve(null);
     if (copy) {
       // We must deep copy the stored data so that the /sync processing code doesn't
@@ -392,29 +376,23 @@ export class LocalIndexedDBStoreBackend {
    * @param userTuples - The user tuples
    * @returns Promise which resolves if the data was persisted.
    */
-  syncToDatabase(userTuples) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      if (_this4.syncToDatabasePromise) {
-        logger.warn("Skipping syncToDatabase() as persist already in flight");
-        _this4.pendingUserPresenceData.push(...userTuples);
-        return _this4.syncToDatabasePromise;
-      }
-      userTuples.unshift(..._this4.pendingUserPresenceData);
-      _this4.syncToDatabasePromise = _this4.doSyncToDatabase(userTuples);
-      return _this4.syncToDatabasePromise;
-    })();
+  async syncToDatabase(userTuples) {
+    if (this.syncToDatabasePromise) {
+      logger.warn("Skipping syncToDatabase() as persist already in flight");
+      this.pendingUserPresenceData.push(...userTuples);
+      return this.syncToDatabasePromise;
+    }
+    userTuples.unshift(...this.pendingUserPresenceData);
+    this.syncToDatabasePromise = this.doSyncToDatabase(userTuples);
+    return this.syncToDatabasePromise;
   }
-  doSyncToDatabase(userTuples) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      try {
-        var syncData = _this5.syncAccumulator.getJSON(true);
-        yield Promise.all([_this5.persistUserPresenceEvents(userTuples), _this5.persistAccountData(syncData.accountData), _this5.persistSyncData(syncData.nextBatch, syncData.roomsData)]);
-      } finally {
-        _this5.syncToDatabasePromise = undefined;
-      }
-    })();
+  async doSyncToDatabase(userTuples) {
+    try {
+      const syncData = this.syncAccumulator.getJSON(true);
+      await Promise.all([this.persistUserPresenceEvents(userTuples), this.persistAccountData(syncData.accountData), this.persistSyncData(syncData.nextBatch, syncData.roomsData)]);
+    } finally {
+      this.syncToDatabasePromise = undefined;
+    }
   }
 
   /**
@@ -426,8 +404,8 @@ export class LocalIndexedDBStoreBackend {
   persistSyncData(nextBatch, roomsData) {
     logger.log("Persisting sync data up to", nextBatch);
     return promiseTry(() => {
-      var txn = this.db.transaction(["sync"], "readwrite");
-      var store = txn.objectStore("sync");
+      const txn = this.db.transaction(["sync"], "readwrite");
+      const store = txn.objectStore("sync");
       store.put({
         clobber: "-",
         // constant key so will always clobber
@@ -448,9 +426,9 @@ export class LocalIndexedDBStoreBackend {
    */
   persistAccountData(accountData) {
     return promiseTry(() => {
-      var txn = this.db.transaction(["accountData"], "readwrite");
-      var store = txn.objectStore("accountData");
-      for (var event of accountData) {
+      const txn = this.db.transaction(["accountData"], "readwrite");
+      const store = txn.objectStore("accountData");
+      for (const event of accountData) {
         store.put(event); // put == UPSERT
       }
       return txnAsPromise(txn).then();
@@ -467,9 +445,9 @@ export class LocalIndexedDBStoreBackend {
    */
   persistUserPresenceEvents(tuples) {
     return promiseTry(() => {
-      var txn = this.db.transaction(["users"], "readwrite");
-      var store = txn.objectStore("users");
-      for (var tuple of tuples) {
+      const txn = this.db.transaction(["users"], "readwrite");
+      const store = txn.objectStore("users");
+      for (const tuple of tuples) {
         store.put({
           userId: tuple[0],
           event: tuple[1]
@@ -487,8 +465,8 @@ export class LocalIndexedDBStoreBackend {
    */
   getUserPresenceEvents() {
     return promiseTry(() => {
-      var txn = this.db.transaction(["users"], "readonly");
-      var store = txn.objectStore("users");
+      const txn = this.db.transaction(["users"], "readonly");
+      const store = txn.objectStore("users");
       return selectQuery(store, undefined, cursor => {
         return [cursor.value.userId, cursor.value.event];
       });
@@ -500,14 +478,14 @@ export class LocalIndexedDBStoreBackend {
    * @returns A list of raw global account events.
    */
   loadAccountData() {
-    logger.log("LocalIndexedDBStoreBackend: loading account data...");
+    logger.log(`LocalIndexedDBStoreBackend: loading account data...`);
     return promiseTry(() => {
-      var txn = this.db.transaction(["accountData"], "readonly");
-      var store = txn.objectStore("accountData");
+      const txn = this.db.transaction(["accountData"], "readonly");
+      const store = txn.objectStore("accountData");
       return selectQuery(store, undefined, cursor => {
         return cursor.value;
       }).then(result => {
-        logger.log("LocalIndexedDBStoreBackend: loaded account data");
+        logger.log(`LocalIndexedDBStoreBackend: loaded account data`);
         return result;
       });
     });
@@ -518,14 +496,14 @@ export class LocalIndexedDBStoreBackend {
    * @returns An object with "roomsData" and "nextBatch" keys.
    */
   loadSyncData() {
-    logger.log("LocalIndexedDBStoreBackend: loading sync data...");
+    logger.log(`LocalIndexedDBStoreBackend: loading sync data...`);
     return promiseTry(() => {
-      var txn = this.db.transaction(["sync"], "readonly");
-      var store = txn.objectStore("sync");
+      const txn = this.db.transaction(["sync"], "readonly");
+      const store = txn.objectStore("sync");
       return selectQuery(store, undefined, cursor => {
         return cursor.value;
       }).then(results => {
-        logger.log("LocalIndexedDBStoreBackend: loaded sync data");
+        logger.log(`LocalIndexedDBStoreBackend: loaded sync data`);
         if (results.length > 1) {
           logger.warn("loadSyncData: More than 1 sync row found.");
         }
@@ -535,114 +513,93 @@ export class LocalIndexedDBStoreBackend {
   }
   getClientOptions() {
     return Promise.resolve().then(() => {
-      var txn = this.db.transaction(["client_options"], "readonly");
-      var store = txn.objectStore("client_options");
+      const txn = this.db.transaction(["client_options"], "readonly");
+      const store = txn.objectStore("client_options");
       return selectQuery(store, undefined, cursor => {
-        var _cursor$value;
-        return (_cursor$value = cursor.value) === null || _cursor$value === void 0 ? void 0 : _cursor$value.options;
+        return cursor.value?.options;
       }).then(results => results[0]);
     });
   }
-  storeClientOptions(options) {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      var txn = _this6.db.transaction(["client_options"], "readwrite");
-      var store = txn.objectStore("client_options");
-      store.put({
-        clobber: "-",
-        // constant key so will always clobber
-        options: options
-      }); // put == UPSERT
-      yield txnAsPromise(txn);
-    })();
+  async storeClientOptions(options) {
+    const txn = this.db.transaction(["client_options"], "readwrite");
+    const store = txn.objectStore("client_options");
+    store.put({
+      clobber: "-",
+      // constant key so will always clobber
+      options: options
+    }); // put == UPSERT
+    await txnAsPromise(txn);
   }
-  saveToDeviceBatches(batches) {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      var txn = _this7.db.transaction(["to_device_queue"], "readwrite");
-      var store = txn.objectStore("to_device_queue");
-      for (var batch of batches) {
-        store.add(batch);
-      }
-      yield txnAsPromise(txn);
-    })();
+  async saveToDeviceBatches(batches) {
+    const txn = this.db.transaction(["to_device_queue"], "readwrite");
+    const store = txn.objectStore("to_device_queue");
+    for (const batch of batches) {
+      store.add(batch);
+    }
+    await txnAsPromise(txn);
   }
-  getOldestToDeviceBatch() {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      var txn = _this8.db.transaction(["to_device_queue"], "readonly");
-      var store = txn.objectStore("to_device_queue");
-      var cursor = yield reqAsCursorPromise(store.openCursor());
-      if (!cursor) return null;
-      var resultBatch = cursor.value;
-      return {
-        id: cursor.key,
-        txnId: resultBatch.txnId,
-        eventType: resultBatch.eventType,
-        batch: resultBatch.batch
-      };
-    })();
+  async getOldestToDeviceBatch() {
+    const txn = this.db.transaction(["to_device_queue"], "readonly");
+    const store = txn.objectStore("to_device_queue");
+    const cursor = await reqAsCursorPromise(store.openCursor());
+    if (!cursor) return null;
+    const resultBatch = cursor.value;
+    return {
+      id: cursor.key,
+      txnId: resultBatch.txnId,
+      eventType: resultBatch.eventType,
+      batch: resultBatch.batch
+    };
+  }
+  async removeToDeviceBatch(id) {
+    const txn = this.db.transaction(["to_device_queue"], "readwrite");
+    const store = txn.objectStore("to_device_queue");
+    store.delete(id);
+    await txnAsPromise(txn);
   }
-  removeToDeviceBatch(id) {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      var txn = _this9.db.transaction(["to_device_queue"], "readwrite");
-      var store = txn.objectStore("to_device_queue");
-      store.delete(id);
-      yield txnAsPromise(txn);
-    })();
+  async getUserProfile(userId) {
+    return Promise.resolve().then(() => {
+      const txn = this.db.transaction(["user_profile"], "readonly");
+      const store = txn.objectStore("user_profile");
+      return selectQuery(store, [userId], cursor => {
+        return cursor.value?.profile;
+      }).then(results => results[0]);
+    });
   }
-  getUserProfile(userId) {
-    var _this0 = this;
-    return _asyncToGenerator(function* () {
-      return Promise.resolve().then(() => {
-        var txn = _this0.db.transaction(["user_profile"], "readonly");
-        var store = txn.objectStore("user_profile");
-        return selectQuery(store, [userId], cursor => {
-          var _cursor$value2;
-          return (_cursor$value2 = cursor.value) === null || _cursor$value2 === void 0 ? void 0 : _cursor$value2.profile;
-        }).then(results => results[0]);
+  async storeUserProfiles(userProfiles) {
+    const txn = this.db.transaction(["user_profile"], "readwrite");
+    const store = txn.objectStore("user_profile");
+    for (const [userId, profile] of userProfiles.entries()) {
+      store.put({
+        profile,
+        userId
       });
-    })();
+    }
+    await txnAsPromise(txn);
   }
-  storeUserProfiles(userProfiles) {
-    var _this1 = this;
-    return _asyncToGenerator(function* () {
-      var txn = _this1.db.transaction(["user_profile"], "readwrite");
-      var store = txn.objectStore("user_profile");
-      for (var _ref6 of userProfiles.entries()) {
-        var _ref5 = _slicedToArray(_ref6, 2);
-        var userId = _ref5[0];
-        var profile = _ref5[1];
-        store.put({
-          profile,
-          userId
-        });
-      }
-      yield txnAsPromise(txn);
-    })();
+  async removeUserProfiles(userIds) {
+    const txn = this.db.transaction(["user_profile"], "readwrite");
+    const store = txn.objectStore("user_profile");
+    for (const userId of userIds) {
+      store.delete([userId]);
+    }
+    await txnAsPromise(txn);
   }
-  removeUserProfiles(userIds) {
-    var _this10 = this;
-    return _asyncToGenerator(function* () {
-      var txn = _this10.db.transaction(["user_profile"], "readwrite");
-      var store = txn.objectStore("user_profile");
-      for (var userId of userIds) {
-        store.delete([userId]);
-      }
-      yield txnAsPromise(txn);
-    })();
+  async removeEventsFromRoom(roomId, eventIds) {
+    try {
+      this.syncAccumulator.removeEventsFromRoom(roomId, eventIds);
+      const syncData = this.syncAccumulator.getJSON(true);
+      await this.persistSyncData(syncData.nextBatch, syncData.roomsData);
+    } finally {
+      this.syncToDatabasePromise = undefined;
+    }
   }
 
   /*
    * Close the database
    */
-  destroy() {
-    var _this11 = this;
-    return _asyncToGenerator(function* () {
-      var _this11$db;
-      (_this11$db = _this11.db) === null || _this11$db === void 0 || _this11$db.close();
-    })();
+  async destroy() {
+    this.db?.close();
   }
 }
 //# sourceMappingURL=indexeddb-local-backend.js.map